home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / devel / lisp / kcl_tar.z / kcl_tar / lsp / seqlib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-04  |  58.9 KB  |  2,915 lines
  1.  
  2. /* (C) Copyright Taiichi Yuasa and Masami Hagiya, 1984. All rights reserved. */
  3. #include <cmpinclude.h>
  4. #include "seqlib.h"
  5. init_seqlib(start,size,data)char *start;int size;object data;
  6. {    register object *base=vs_top;register object *sup=base+VM2;vs_top=sup;vs_check;
  7.     Cstart=start;Csize=size;Cdata=data;set_VV(VV,VM1,data);
  8.     base[0]= VV[0];
  9.     (void)simple_symlispcall_no_event(VV[36],base+0,1);
  10.     base[0]= VV[1];
  11.     (void)simple_symlispcall_no_event(VV[36],base+0,1);
  12.     MF(VV[37],L3,start,size,data);
  13.     base[0]= VV[7];
  14.     (void)simple_symlispcall_no_event(VV[36],base+0,1);
  15.     MF(VV[38],L5,start,size,data);
  16.     base[0]= VV[8];
  17.     (void)simple_symlispcall_no_event(VV[36],base+0,1);
  18.     MF(VV[39],L7,start,size,data);
  19.     base[0]= VV[10];
  20.     (void)simple_symlispcall_no_event(VV[36],base+0,1);
  21.     MF(VV[40],L9,start,size,data);
  22.     base[0]= VV[13];
  23.     (void)simple_symlispcall_no_event(VV[36],base+0,1);
  24.     MF(VV[41],L11,start,size,data);
  25.     MF(VV[42],L12,start,size,data);
  26.     MF(VV[43],L13,start,size,data);
  27.     MF(VV[44],L14,start,size,data);
  28.     MF(VV[26],L15,start,size,data);
  29.     MF(VV[45],L16,start,size,data);
  30.     MF(VV[46],L17,start,size,data);
  31.     MF(VV[27],L19,start,size,data);
  32.     MF(VV[47],L20,start,size,data);
  33.     MF(VV[48],L21,start,size,data);
  34.     MF(VV[28],L23,start,size,data);
  35.     MF(VV[49],L24,start,size,data);
  36.     MF(VV[50],L25,start,size,data);
  37.     MF(VV[29],L27,start,size,data);
  38.     MF(VV[51],L28,start,size,data);
  39.     MF(VV[52],L29,start,size,data);
  40.     MF(VV[30],L31,start,size,data);
  41.     MF(VV[53],L32,start,size,data);
  42.     MF(VV[54],L33,start,size,data);
  43.     MF(VV[31],L35,start,size,data);
  44.     MF(VV[55],L36,start,size,data);
  45.     MF(VV[56],L37,start,size,data);
  46.     MF(VV[32],L39,start,size,data);
  47.     MF(VV[57],L40,start,size,data);
  48.     MF(VV[58],L41,start,size,data);
  49.     MF(VV[33],L43,start,size,data);
  50.     MF(VV[59],L44,start,size,data);
  51.     MF(VV[60],L45,start,size,data);
  52.     MF(VV[61],L47,start,size,data);
  53.     MF(VV[62],L48,start,size,data);
  54.     MF(VV[63],L49,start,size,data);
  55.     MF(VV[64],L50,start,size,data);
  56.     MF(VV[65],L51,start,size,data);
  57.     MF(VV[66],L52,start,size,data);
  58.     base[0]= VV[35];
  59.     (void)simple_symlispcall_no_event(VV[36],base+0,1);
  60.     MF(VV[67],L55,start,size,data);
  61.     MF(VV[68],L56,start,size,data);
  62.     MF(VV[69],L57,start,size,data);
  63.     vs_top=vs_base=base;
  64. }
  65. /*    local entry for function SEQTYPE    */
  66.  
  67. static object LI3(V2)
  68. object V2;
  69. {    VMB3 VMS3 VMV3
  70. TTL:;
  71.     if(!(type_of((V2))==t_cons||(V2)==Cnil)){
  72.     goto T24;}
  73.     VMR3(VV[2])
  74. T24:;
  75.     if(!(type_of((V2))==t_string)){
  76.     goto T27;}
  77.     VMR3(VV[3])
  78. T27:;
  79.     base[0]= (V2);
  80.     vs_top=(vs_base=base+0)+1;
  81.     Lbit_vector_p();
  82.     vs_top=sup;
  83.     if((vs_base[0])==Cnil){
  84.     goto T30;}
  85.     VMR3(VV[4])
  86. T30:;
  87.     if(!(type_of((V2))==t_vector||
  88. type_of((V2))==t_string||
  89. type_of((V2))==t_bitvector)){
  90.     goto T34;}
  91.     base[1]= (V2);
  92.     vs_top=(vs_base=base+1)+1;
  93.     Larray_element_type();
  94.     vs_top=sup;
  95.     base[0]= vs_base[0];
  96.     VMR3(list(2,VV[5],base[0]))
  97. T34:;
  98.     base[0]= VV[6];
  99.     base[1]= (V2);
  100.     vs_top=(vs_base=base+0)+2;
  101.     Lerror();
  102.     vs_top=sup;
  103.     VMR3(vs_base[0])
  104. }
  105. /*    local entry for function CALL-TEST    */
  106.  
  107. static object LI5(V7,V8,V9,V10)
  108. object V7,V8,V9,V10;
  109. {    VMB4 VMS4 VMV4
  110. TTL:;
  111.     if(((V7))==Cnil){
  112.     goto T41;}
  113.     base[0]= (V9);
  114.     base[1]= (V10);
  115.     vs_top=(vs_base=base+0)+2;
  116.     super_funcall_no_event((V7));
  117.     vs_top=sup;
  118.     VMR4(vs_base[0])
  119. T41:;
  120.     if(((V8))==Cnil){
  121.     goto T46;}
  122.     base[1]= (V9);
  123.     base[2]= (V10);
  124.     vs_top=(vs_base=base+1)+2;
  125.     super_funcall_no_event((V8));
  126.     vs_top=sup;
  127.     base[0]= vs_base[0];
  128.     VMR4(((base[0])==Cnil?Ct:Cnil))
  129. T46:;
  130.     VMR4((eql((V9),(V10))?Ct:Cnil))
  131. }
  132. /*    local entry for function CHECK-SEQ-TEST    */
  133.  
  134. static object LI7(V13,V14)
  135. object V13,V14;
  136. {    VMB5 VMS5 VMV5
  137. TTL:;
  138.     if(((V13))==Cnil){
  139.     goto T52;}
  140.     if(((V14))==Cnil){
  141.     goto T52;}
  142.     base[0]= VV[9];
  143.     vs_top=(vs_base=base+0)+1;
  144.     Lerror();
  145.     vs_top=sup;
  146.     VMR5(vs_base[0])
  147. T52:;
  148.     VMR5(Cnil)
  149. }
  150. /*    local entry for function CHECK-SEQ-START-END    */
  151.  
  152. static object LI9(V17,V18)
  153. object V17,V18;
  154. {    VMB6 VMS6 VMV6
  155. TTL:;
  156.     base[0]= (V17);
  157.     if((simple_symlispcall_no_event(VV[70],base+0,1))==Cnil){
  158.     goto T58;}
  159.     base[0]= (V18);
  160.     if((simple_symlispcall_no_event(VV[70],base+0,1))!=Cnil){
  161.     goto T57;}
  162. T58:;
  163.     base[0]= VV[11];
  164.     vs_top=(vs_base=base+0)+1;
  165.     Lerror();
  166.     vs_top=sup;
  167. T57:;
  168.     if(!((fix((V17)))>(fix((V18))))){
  169.     goto T66;}
  170.     base[0]= VV[12];
  171.     vs_top=(vs_base=base+0)+1;
  172.     Lerror();
  173.     vs_top=sup;
  174.     VMR6(vs_base[0])
  175. T66:;
  176.     VMR6(Cnil)
  177. }
  178. /*    local entry for function CHECK-SEQ-ARGS    */
  179.  
  180. static object LI11(V23,V24,V25,V26)
  181. object V23,V24,V25,V26;
  182. {    VMB7 VMS7 VMV7
  183. TTL:;
  184.     if(((V23))==Cnil){
  185.     goto T69;}
  186.     if(((V24))==Cnil){
  187.     goto T69;}
  188.     base[0]= VV[14];
  189.     vs_top=(vs_base=base+0)+1;
  190.     Lerror();
  191.     vs_top=sup;
  192. T69:;
  193.     base[0]= (V25);
  194.     if((simple_symlispcall_no_event(VV[70],base+0,1))==Cnil){
  195.     goto T76;}
  196.     base[0]= (V26);
  197.     if((simple_symlispcall_no_event(VV[70],base+0,1))!=Cnil){
  198.     goto T75;}
  199. T76:;
  200.     base[0]= VV[15];
  201.     vs_top=(vs_base=base+0)+1;
  202.     Lerror();
  203.     vs_top=sup;
  204. T75:;
  205.     if(!((fix((V25)))>(fix((V26))))){
  206.     goto T84;}
  207.     base[0]= VV[16];
  208.     vs_top=(vs_base=base+0)+1;
  209.     Lerror();
  210.     vs_top=sup;
  211.     VMR7(vs_base[0])
  212. T84:;
  213.     VMR7(Cnil)
  214. }
  215. /*    function definition for REDUCE    */
  216.  
  217. static L12()
  218. {    register object *base=vs_base;
  219.     register object *sup=base+VM8;
  220.     vs_reserve(VM8);
  221.     if(vs_top-vs_base<2) too_few_arguments();
  222.     parse_key(vs_base+2,FALSE,FALSE,4,VV[19],VV[22],VV[23],VV[71]);
  223.     vs_top=sup;
  224.     if(base[7]==Cnil){
  225.     base[3]= VV[17];
  226.     }else{}
  227.     if(base[8]==Cnil){
  228.     base[4]= make_fixnum(length(base[1]));
  229.     }else{}
  230.     (void)(LI9(base[3],base[4]));
  231.     {int V27;
  232.     int V28;
  233.     V27= fix(base[3]);
  234.     V28= fix(base[4]);
  235.     if((base[2])!=Cnil){
  236.     goto T93;}
  237.     if((base[9])!=Cnil){
  238.     goto T95;}
  239.     if(!((V27)>=(V28))){
  240.     goto T98;}
  241.     vs_base=vs_top;
  242.     super_funcall_no_event(base[0]);
  243.     return;
  244. T98:;
  245.     base[5]= elt(base[1],V27);
  246.     V27= (V27)+(1);
  247. T95:;
  248.     base[10]= base[5];
  249. T105:;
  250.     if(!((V27)>=(V28))){
  251.     goto T106;}
  252.     vs_top=(vs_base=base+10)+1;
  253.     return;
  254. T106:;
  255.     base[11]= base[10];
  256.     base[13]= elt(base[1],V27);
  257.     V27= (V27)+(1);
  258.     base[12]= base[13];
  259.     vs_top=(vs_base=base+11)+2;
  260.     super_funcall_no_event(base[0]);
  261.     vs_top=sup;
  262.     base[10]= vs_base[0];
  263.     goto T105;
  264. T93:;
  265.     if((base[9])!=Cnil){
  266.     goto T118;}
  267.     if(!((V27)>=(V28))){
  268.     goto T121;}
  269.     vs_base=vs_top;
  270.     super_funcall_no_event(base[0]);
  271.     return;
  272. T121:;
  273.     V28= (V28)-(1);
  274.     base[5]= elt(base[1],V28);
  275. T118:;
  276.     base[10]= base[5];
  277. T128:;
  278.     if(!((V27)>=(V28))){
  279.     goto T129;}
  280.     vs_top=(vs_base=base+10)+1;
  281.     return;
  282. T129:;
  283.     V28= (V28)-(1);
  284.     base[11]= elt(base[1],V28);
  285.     base[12]= base[10];
  286.     vs_top=(vs_base=base+11)+2;
  287.     super_funcall_no_event(base[0]);
  288.     vs_top=sup;
  289.     base[10]= vs_base[0];
  290.     goto T128;}
  291. }
  292. /*    function definition for FILL    */
  293.  
  294. static L13()
  295. {    register object *base=vs_base;
  296.     register object *sup=base+VM9;
  297.     vs_reserve(VM9);
  298.     if(vs_top-vs_base<2) too_few_arguments();
  299.     parse_key(vs_base+2,FALSE,FALSE,2,VV[22],VV[23]);
  300.     vs_top=sup;
  301.     if(base[4]==Cnil){
  302.     base[2]= VV[17];
  303.     }else{}
  304.     if(base[5]==Cnil){
  305.     base[3]= make_fixnum(length(base[0]));
  306.     }else{}
  307.     (void)(LI9(base[2],base[3]));
  308.     {int V29;
  309.     int V30;
  310.     V29= fix(base[2]);
  311.     V30= fix(base[3]);
  312.     {int V31;
  313.     V31= V29;
  314. T147:;
  315.     if(!((V31)>=(V30))){
  316.     goto T148;}
  317.     vs_top=(vs_base=base+0)+1;
  318.     return;
  319. T148:;
  320.     (void)(elt_set(base[0],V31,base[1]));
  321.     V31= (V31)+1;
  322.     goto T147;}}
  323. }
  324. /*    function definition for REPLACE    */
  325.  
  326. static L14()
  327. {    register object *base=vs_base;
  328.     register object *sup=base+VM10;
  329.     vs_reserve(VM10);
  330.     if(vs_top-vs_base<2) too_few_arguments();
  331.     parse_key(vs_base+2,FALSE,FALSE,4,VV[72],VV[73],VV[74],VV[75]);
  332.     vs_top=sup;
  333.     if(base[6]==Cnil){
  334.     base[2]= VV[17];
  335.     }else{}
  336.     if(base[7]==Cnil){
  337.     base[3]= make_fixnum(length(base[0]));
  338.     }else{}
  339.     if(base[8]==Cnil){
  340.     base[4]= VV[17];
  341.     }else{}
  342.     if(base[9]==Cnil){
  343.     base[5]= make_fixnum(length(base[1]));
  344.     }else{}
  345.     (void)(LI9(base[2],base[3]));
  346.     (void)(LI9(base[4],base[5]));
  347.     {int V32;
  348.     int V33;
  349.     int V34;
  350.     int V35;
  351.     V32= fix(base[2]);
  352.     V33= fix(base[3]);
  353.     V34= fix(base[4]);
  354.     V35= fix(base[5]);
  355.     if(!(base[0]==base[1])){
  356.     goto T167;}
  357.     if(!((V32)>(V34))){
  358.     goto T167;}
  359.     {int V36;
  360.     int V37;
  361.     int V38;
  362.     int V39;
  363.     V36= 0;
  364.     if(!(((V33)-(V32))<((V35)-(V34)))){
  365.     goto T174;}
  366.     V37= (V33)-(V32);
  367.     goto T172;
  368. T174:;
  369.     V37= (V35)-(V34);
  370. T172:;
  371.     V38= (V32)+((V37)-1);
  372.     V39= (V34)+((V37)-1);
  373. T179:;
  374.     if(!((V36)>=(V37))){
  375.     goto T180;}
  376.     vs_top=(vs_base=base+0)+1;
  377.     return;
  378. T180:;
  379.     base[10]= elt(base[1],V39);
  380.     (void)(elt_set(base[0],V38,base[10]));
  381.     V36= (V36)+1;
  382.     V38= (V38)-1;
  383.     V39= (V39)-1;
  384.     goto T179;}
  385. T167:;
  386.     {int V40;
  387.     int V41;
  388.     int V42;
  389.     int V43;
  390.     V40= 0;
  391.     if(!(((V33)-(V32))<((V35)-(V34)))){
  392.     goto T195;}
  393.     V41= (V33)-(V32);
  394.     goto T193;
  395. T195:;
  396.     V41= (V35)-(V34);
  397. T193:;
  398.     V42= V32;
  399.     V43= V34;
  400. T200:;
  401.     if(!((V40)>=(V41))){
  402.     goto T201;}
  403.     vs_top=(vs_base=base+0)+1;
  404.     return;
  405. T201:;
  406.     base[10]= elt(base[1],V43);
  407.     (void)(elt_set(base[0],V42,base[10]));
  408.     V40= (V40)+1;
  409.     V42= (V42)+1;
  410.     V43= (V43)+1;
  411.     goto T200;}}
  412. }
  413. /*    function definition for REMOVE    */
  414.  
  415. static L15()
  416. {    register object *base=vs_base;
  417.     register object *sup=base+VM11;
  418.     vs_reserve(VM11);
  419.     {int V44;
  420.     if(vs_top-vs_base<2) too_few_arguments();
  421.     parse_key(vs_base+2,FALSE,FALSE,7,VV[19],VV[20],VV[21],VV[22],VV[23],VV[24],VV[25]);
  422.     vs_top=sup;
  423.     if(base[12]==Cnil){
  424.     base[5]= VV[17];
  425.     }else{}
  426.     if(base[13]==Cnil){
  427.     base[6]= make_fixnum(length(base[1]));
  428.     }else{}
  429.     if(base[14]==Cnil){
  430.     V44= length(base[1]);
  431.     }else{
  432.     V44=fix(base[7]);}
  433.     if(base[15]==Cnil){
  434.     base[8]= symbol_function(VV[76]);
  435.     }else{}
  436.     (void)(LI11(base[3],base[4],base[5],base[6]));
  437.     {int V45;
  438.     int V46;
  439.     V45= fix(base[5]);
  440.     V46= fix(base[6]);
  441.     if((base[2])!=Cnil){
  442.     goto T219;}
  443.     if(!(type_of(base[1])==t_cons||base[1]==Cnil)){
  444.     goto T222;}
  445.     base[16]= base[1];
  446.     base[17]= Cnil;
  447.     {int V47;
  448.     V47= 0;
  449. T227:;
  450.     if(!((V47)>=(V45))){
  451.     goto T228;}
  452.     goto T224;
  453. T228:;
  454.     base[17]= make_cons(car(base[16]),base[17]);
  455.     base[18]= car(base[16]);
  456.     base[16]= cdr(base[16]);
  457.     V47= (V47)+1;
  458.     goto T227;}
  459. T224:;
  460.     {int V48;
  461.     int V49;
  462.     V48= V45;
  463.     V49= 0;
  464. T244:;
  465.     if((V48)>=(V46)){
  466.     goto T246;}
  467.     if((V49)>=(V44)){
  468.     goto T246;}
  469.     if(!(endp(base[16]))){
  470.     goto T245;}
  471. T246:;
  472.     base[18]= base[17];
  473.     base[19]= base[16];
  474.     vs_top=(vs_base=base+18)+2;
  475.     Lreconc();
  476.     return;
  477. T245:;
  478.     base[19]= car(base[16]);
  479.     vs_top=(vs_base=base+19)+1;
  480.     super_funcall_no_event(base[8]);
  481.     vs_top=sup;
  482.     base[18]= vs_base[0];
  483.     if((LI5(base[3],base[4],base[0],base[18]))==Cnil){
  484.     goto T257;}
  485.     V49= (V49)+(1);
  486.     base[18]= car(base[16]);
  487.     base[16]= cdr(base[16]);
  488.     goto T255;
  489. T257:;
  490.     base[17]= make_cons(car(base[16]),base[17]);
  491.     base[18]= car(base[16]);
  492.     base[16]= cdr(base[16]);
  493. T255:;
  494.     V48= (V48)+1;
  495.     goto T244;}
  496. T222:;
  497.     base[16]= base[0];
  498.     base[17]= base[1];
  499.     base[18]= VV[19];
  500.     base[19]= base[2];
  501.     base[20]= VV[20];
  502.     base[21]= base[3];
  503.     base[22]= VV[21];
  504.     base[23]= base[4];
  505.     base[24]= VV[22];
  506.     base[25]= make_fixnum(V45);
  507.     base[26]= VV[23];
  508.     base[27]= make_fixnum(V46);
  509.     base[28]= VV[24];
  510.     base[29]= make_fixnum(V44);
  511.     base[30]= VV[25];
  512.     base[31]= base[8];
  513.     vs_top=(vs_base=base+16)+16;
  514.     L19();
  515.     return;
  516. T219:;
  517.     base[16]= base[0];
  518.     base[17]= base[1];
  519.     base[18]= VV[19];
  520.     base[19]= base[2];
  521.     base[20]= VV[20];
  522.     base[21]= base[3];
  523.     base[22]= VV[21];
  524.     base[23]= base[4];
  525.     base[24]= VV[22];
  526.     base[25]= make_fixnum(V45);
  527.     base[26]= VV[23];
  528.     base[27]= make_fixnum(V46);
  529.     base[28]= VV[24];
  530.     base[29]= make_fixnum(V44);
  531.     base[30]= VV[25];
  532.     base[31]= base[8];
  533.     vs_top=(vs_base=base+16)+16;
  534.     L19();
  535.     return;}
  536.     }
  537. }
  538. /*    function definition for REMOVE-IF    */
  539.  
  540. static L16()
  541. {    register object *base=vs_base;
  542.     register object *sup=base+VM12;
  543.     vs_reserve(VM12);
  544.     if(vs_top-vs_base<2) too_few_arguments();
  545.     parse_key(vs_base+2,FALSE,FALSE,5,VV[19],VV[22],VV[23],VV[24],VV[25]);
  546.     vs_top=sup;
  547.     if(base[8]==Cnil){
  548.     base[3]= VV[17];
  549.     }else{}
  550.     if(base[9]==Cnil){
  551.     base[4]= make_fixnum(length(base[1]));
  552.     }else{}
  553.     if(base[10]==Cnil){
  554.     base[5]= make_fixnum(length(base[1]));
  555.     }else{}
  556.     if(base[11]==Cnil){
  557.     base[6]= symbol_function(VV[76]);
  558.     }else{}
  559.     base[12]= base[0];
  560.     base[13]= base[1];
  561.     base[14]= VV[19];
  562.     base[15]= base[2];
  563.     base[16]= VV[20];
  564.     base[17]= symbol_function(VV[77]);
  565.     base[18]= VV[22];
  566.     base[19]= base[3];
  567.     base[20]= VV[23];
  568.     base[21]= base[4];
  569.     base[22]= VV[24];
  570.     base[23]= base[5];
  571.     base[24]= VV[25];
  572.     base[25]= base[6];
  573.     vs_top=(vs_base=base+12)+14;
  574.     L15();
  575.     return;
  576. }
  577. /*    function definition for REMOVE-IF-NOT    */
  578.  
  579. static L17()
  580. {    register object *base=vs_base;
  581.     register object *sup=base+VM13;
  582.     vs_reserve(VM13);
  583.     if(vs_top-vs_base<2) too_few_arguments();
  584.     parse_key(vs_base+2,FALSE,FALSE,5,VV[19],VV[22],VV[23],VV[24],VV[25]);
  585.     vs_top=sup;
  586.     if(base[8]==Cnil){
  587.     base[3]= VV[17];
  588.     }else{}
  589.     if(base[9]==Cnil){
  590.     base[4]= make_fixnum(length(base[1]));
  591.     }else{}
  592.     if(base[10]==Cnil){
  593.     base[5]= make_fixnum(length(base[1]));
  594.     }else{}
  595.     if(base[11]==Cnil){
  596.     base[6]= symbol_function(VV[76]);
  597.     }else{}
  598.     base[12]= base[0];
  599.     base[13]= base[1];
  600.     base[14]= VV[19];
  601.     base[15]= base[2];
  602.     base[16]= VV[21];
  603.     base[17]= symbol_function(VV[77]);
  604.     base[18]= VV[22];
  605.     base[19]= base[3];
  606.     base[20]= VV[23];
  607.     base[21]= base[4];
  608.     base[22]= VV[24];
  609.     base[23]= base[5];
  610.     base[24]= VV[25];
  611.     base[25]= base[6];
  612.     vs_top=(vs_base=base+12)+14;
  613.     L15();
  614.     return;
  615. }
  616. /*    function definition for DELETE    */
  617.  
  618. static L19()
  619. {    register object *base=vs_base;
  620.     register object *sup=base+VM14;
  621.     vs_reserve(VM14);
  622.     {int V50;
  623.     if(vs_top-vs_base<2) too_few_arguments();
  624.     parse_key(vs_base+2,FALSE,FALSE,7,VV[19],VV[20],VV[21],VV[22],VV[23],VV[24],VV[25]);
  625.     vs_top=sup;
  626.     if(base[12]==Cnil){
  627.     base[5]= VV[17];
  628.     }else{}
  629.     if(base[13]==Cnil){
  630.     base[6]= make_fixnum(length(base[1]));
  631.     }else{}
  632.     if(base[14]==Cnil){
  633.     V50= length(base[1]);
  634.     }else{
  635.     V50=fix(base[7]);}
  636.     if(base[15]==Cnil){
  637.     base[8]= symbol_function(VV[76]);
  638.     }else{}
  639.     {int V51;
  640.     V51= length(base[1]);
  641.     (void)(LI11(base[3],base[4],base[5],base[6]));
  642.     {int V52;
  643.     int V53;
  644.     V52= fix(base[5]);
  645.     V53= fix(base[6]);
  646.     if((base[2])!=Cnil){
  647.     goto T351;}
  648.     if(!(type_of(base[1])==t_cons||base[1]==Cnil)){
  649.     goto T354;}
  650.     base[16]= make_cons(Cnil,base[1]);
  651.     base[17]= base[16];
  652.     {int V54;
  653.     V54= 0;
  654. T360:;
  655.     if(!((V54)>=(V52))){
  656.     goto T361;}
  657.     goto T357;
  658. T361:;
  659.     base[18]= car(base[17]);
  660.     base[17]= cdr(base[17]);
  661.     V54= (V54)+1;
  662.     goto T360;}
  663. T357:;
  664.     {int V55;
  665.     int V56;
  666.     V55= V52;
  667.     V56= 0;
  668. T375:;
  669.     if((V55)>=(V53)){
  670.     goto T377;}
  671.     if((V56)>=(V50)){
  672.     goto T377;}
  673.     if(!(endp(cdr(base[17])))){
  674.     goto T376;}
  675. T377:;
  676.     base[18]= cdr(base[16]);
  677.     vs_top=(vs_base=base+18)+1;
  678.     return;
  679. T376:;
  680.     base[19]= cadr(base[17]);
  681.     vs_top=(vs_base=base+19)+1;
  682.     super_funcall_no_event(base[8]);
  683.     vs_top=sup;
  684.     base[18]= vs_base[0];
  685.     if((LI5(base[3],base[4],base[0],base[18]))==Cnil){
  686.     goto T386;}
  687.     V56= (V56)+(1);
  688.     if(type_of(base[17])!=t_cons)FEwrong_type_argument(Scons,base[17]);
  689.     (base[17])->c.c_cdr = cddr(base[17]);
  690.     goto T384;
  691. T386:;
  692.     base[17]= cdr(base[17]);
  693. T384:;
  694.     V55= (V55)+1;
  695.     goto T375;}
  696. T354:;
  697.     {int V57;
  698.     base[16]= base[0];
  699.     base[17]= base[1];
  700.     base[18]= VV[19];
  701.     base[19]= base[2];
  702.     base[20]= VV[20];
  703.     base[21]= base[3];
  704.     base[22]= VV[21];
  705.     base[23]= base[4];
  706.     base[24]= VV[22];
  707.     base[25]= make_fixnum(V52);
  708.     base[26]= VV[23];
  709.     base[27]= make_fixnum(V53);
  710.     base[28]= VV[24];
  711.     base[29]= make_fixnum(V50);
  712.     base[30]= VV[25];
  713.     base[31]= base[8];
  714.     vs_top=(vs_base=base+16)+16;
  715.     L27();
  716.     vs_top=sup;
  717.     V57= fix(vs_base[0]);
  718.     if(!((V57)<(V50))){
  719.     goto T413;}
  720.     V50= V57;
  721. T413:;
  722.     {int V58;
  723.     int V59;
  724.     int V60;
  725.     base[17]=symbol_function(VV[78]);
  726.     base[18]= LI3(base[1]);
  727.     base[19]= make_fixnum((V51)-(V50));
  728.     base[16]= simple_lispcall_no_event(base+17,2);
  729.     V58= 0;
  730.     V59= V52;
  731.     V60= 0;
  732. T424:;
  733.     if(!((V58)>=(V51))){
  734.     goto T425;}
  735.     vs_top=(vs_base=base+16)+1;
  736.     return;
  737. T425:;
  738.     if(!((V52)<=(V58))){
  739.     goto T431;}
  740.     if(!((V58)<(V53))){
  741.     goto T431;}
  742.     if(!((V60)<(V50))){
  743.     goto T431;}
  744.     base[18]= elt(base[1],V58);
  745.     vs_top=(vs_base=base+18)+1;
  746.     super_funcall_no_event(base[8]);
  747.     vs_top=sup;
  748.     base[17]= vs_base[0];
  749.     if((LI5(base[3],base[4],base[0],base[17]))==Cnil){
  750.     goto T431;}
  751.     V60= (V60)+1;
  752.     goto T429;
  753. T431:;
  754.     base[17]= elt(base[1],V58);
  755.     (void)(elt_set(base[16],V59,base[17]));
  756.     V59= (V59)+(1);
  757. T429:;
  758.     V58= (V58)+1;
  759.     goto T424;}}
  760. T351:;
  761.     {int V61;
  762.     base[16]= base[0];
  763.     base[17]= base[1];
  764.     base[18]= VV[19];
  765.     base[19]= base[2];
  766.     base[20]= VV[20];
  767.     base[21]= base[3];
  768.     base[22]= VV[21];
  769.     base[23]= base[4];
  770.     base[24]= VV[22];
  771.     base[25]= make_fixnum(V52);
  772.     base[26]= VV[23];
  773.     base[27]= make_fixnum(V53);
  774.     base[28]= VV[24];
  775.     base[29]= make_fixnum(V50);
  776.     base[30]= VV[25];
  777.     base[31]= base[8];
  778.     vs_top=(vs_base=base+16)+16;
  779.     L27();
  780.     vs_top=sup;
  781.     V61= fix(vs_base[0]);
  782.     if(!((V61)<(V50))){
  783.     goto T464;}
  784.     V50= V61;
  785. T464:;
  786.     {int V62;
  787.     int V63;
  788.     int V64;
  789.     base[17]=symbol_function(VV[78]);
  790.     base[18]= LI3(base[1]);
  791.     base[19]= make_fixnum((V51)-(V50));
  792.     base[16]= simple_lispcall_no_event(base+17,2);
  793.     V62= (V51)-1;
  794.     V63= ((V53)-1)-(V61);
  795.     V64= 0;
  796. T475:;
  797.     if(!((V62)<(0))){
  798.     goto T476;}
  799.     vs_top=(vs_base=base+16)+1;
  800.     return;
  801. T476:;
  802.     if(!((V52)<=(V62))){
  803.     goto T482;}
  804.     if(!((V62)<(V53))){
  805.     goto T482;}
  806.     if(!((V64)<(V50))){
  807.     goto T482;}
  808.     base[18]= elt(base[1],V62);
  809.     vs_top=(vs_base=base+18)+1;
  810.     super_funcall_no_event(base[8]);
  811.     vs_top=sup;
  812.     base[17]= vs_base[0];
  813.     if((LI5(base[3],base[4],base[0],base[17]))==Cnil){
  814.     goto T482;}
  815.     V64= (V64)+1;
  816.     goto T480;
  817. T482:;
  818.     base[17]= elt(base[1],V62);
  819.     (void)(elt_set(base[16],V63,base[17]));
  820.     V63= (V63)-(1);
  821. T480:;
  822.     V62= (V62)-1;
  823.     goto T475;}}}}
  824.     }
  825. }
  826. /*    function definition for DELETE-IF    */
  827.  
  828. static L20()
  829. {    register object *base=vs_base;
  830.     register object *sup=base+VM15;
  831.     vs_reserve(VM15);
  832.     if(vs_top-vs_base<2) too_few_arguments();
  833.     parse_key(vs_base+2,FALSE,FALSE,5,VV[19],VV[22],VV[23],VV[24],VV[25]);
  834.     vs_top=sup;
  835.     if(base[8]==Cnil){
  836.     base[3]= VV[17];
  837.     }else{}
  838.     if(base[9]==Cnil){
  839.     base[4]= make_fixnum(length(base[1]));
  840.     }else{}
  841.     if(base[10]==Cnil){
  842.     base[5]= make_fixnum(length(base[1]));
  843.     }else{}
  844.     if(base[11]==Cnil){
  845.     base[6]= symbol_function(VV[76]);
  846.     }else{}
  847.     base[12]= base[0];
  848.     base[13]= base[1];
  849.     base[14]= VV[19];
  850.     base[15]= base[2];
  851.     base[16]= VV[20];
  852.     base[17]= symbol_function(VV[77]);
  853.     base[18]= VV[22];
  854.     base[19]= base[3];
  855.     base[20]= VV[23];
  856.     base[21]= base[4];
  857.     base[22]= VV[24];
  858.     base[23]= base[5];
  859.     base[24]= VV[25];
  860.     base[25]= base[6];
  861.     vs_top=(vs_base=base+12)+14;
  862.     L19();
  863.     return;
  864. }
  865. /*    function definition for DELETE-IF-NOT    */
  866.  
  867. static L21()
  868. {    register object *base=vs_base;
  869.     register object *sup=base+VM16;
  870.     vs_reserve(VM16);
  871.     if(vs_top-vs_base<2) too_few_arguments();
  872.     parse_key(vs_base+2,FALSE,FALSE,5,VV[19],VV[22],VV[23],VV[24],VV[25]);
  873.     vs_top=sup;
  874.     if(base[8]==Cnil){
  875.     base[3]= VV[17];
  876.     }else{}
  877.     if(base[9]==Cnil){
  878.     base[4]= make_fixnum(length(base[1]));
  879.     }else{}
  880.     if(base[10]==Cnil){
  881.     base[5]= make_fixnum(length(base[1]));
  882.     }else{}
  883.     if(base[11]==Cnil){
  884.     base[6]= symbol_function(VV[76]);
  885.     }else{}
  886.     base[12]= base[0];
  887.     base[13]= base[1];
  888.     base[14]= VV[19];
  889.     base[15]= base[2];
  890.     base[16]= VV[21];
  891.     base[17]= symbol_function(VV[77]);
  892.     base[18]= VV[22];
  893.     base[19]= base[3];
  894.     base[20]= VV[23];
  895.     base[21]= base[4];
  896.     base[22]= VV[24];
  897.     base[23]= base[5];
  898.     base[24]= VV[25];
  899.     base[25]= base[6];
  900.     vs_top=(vs_base=base+12)+14;
  901.     L19();
  902.     return;
  903. }
  904. /*    function definition for COUNT    */
  905.  
  906. static L23()
  907. {    register object *base=vs_base;
  908.     register object *sup=base+VM17;
  909.     vs_reserve(VM17);
  910.     if(vs_top-vs_base<2) too_few_arguments();
  911.     parse_key(vs_base+2,FALSE,FALSE,6,VV[19],VV[20],VV[21],VV[22],VV[23],VV[25]);
  912.     vs_top=sup;
  913.     if(base[11]==Cnil){
  914.     base[5]= VV[17];
  915.     }else{}
  916.     if(base[12]==Cnil){
  917.     base[6]= make_fixnum(length(base[1]));
  918.     }else{}
  919.     if(base[13]==Cnil){
  920.     base[7]= symbol_function(VV[76]);
  921.     }else{}
  922.     (void)(LI11(base[3],base[4],base[5],base[6]));
  923.     {int V65;
  924.     int V66;
  925.     V65= fix(base[5]);
  926.     V66= fix(base[6]);
  927.     if((base[2])!=Cnil){
  928.     goto T541;}
  929.     {int V67;
  930.     int V68;
  931.     V67= V65;
  932.     V68= 0;
  933. T546:;
  934.     if(!((V67)>=(V66))){
  935.     goto T547;}
  936.     base[14]= make_fixnum(V68);
  937.     vs_top=(vs_base=base+14)+1;
  938.     return;
  939. T547:;
  940.     base[15]= elt(base[1],V67);
  941.     vs_top=(vs_base=base+15)+1;
  942.     super_funcall_no_event(base[7]);
  943.     vs_top=sup;
  944.     base[14]= vs_base[0];
  945.     if((LI5(base[3],base[4],base[0],base[14]))==Cnil){
  946.     goto T551;}
  947.     V68= (V68)+1;
  948. T551:;
  949.     V67= (V67)+1;
  950.     goto T546;}
  951. T541:;
  952.     {int V69;
  953.     int V70;
  954.     V69= (V66)-1;
  955.     V70= 0;
  956. T563:;
  957.     if(!((V69)<(V65))){
  958.     goto T564;}
  959.     base[14]= make_fixnum(V70);
  960.     vs_top=(vs_base=base+14)+1;
  961.     return;
  962. T564:;
  963.     base[15]= elt(base[1],V69);
  964.     vs_top=(vs_base=base+15)+1;
  965.     super_funcall_no_event(base[7]);
  966.     vs_top=sup;
  967.     base[14]= vs_base[0];
  968.     if((LI5(base[3],base[4],base[0],base[14]))==Cnil){
  969.     goto T568;}
  970.     V70= (V70)+1;
  971. T568:;
  972.     V69= (V69)-1;
  973.     goto T563;}}
  974. }
  975. /*    function definition for COUNT-IF    */
  976.  
  977. static L24()
  978. {    register object *base=vs_base;
  979.     register object *sup=base+VM18;
  980.     vs_reserve(VM18);
  981.     if(vs_top-vs_base<2) too_few_arguments();
  982.     parse_key(vs_base+2,FALSE,FALSE,4,VV[19],VV[22],VV[23],VV[25]);
  983.     vs_top=sup;
  984.     if(base[7]==Cnil){
  985.     base[3]= VV[17];
  986.     }else{}
  987.     if(base[8]==Cnil){
  988.     base[4]= make_fixnum(length(base[1]));
  989.     }else{}
  990.     if(base[9]==Cnil){
  991.     base[5]= symbol_function(VV[76]);
  992.     }else{}
  993.     base[10]= base[0];
  994.     base[11]= base[1];
  995.     base[12]= VV[19];
  996.     base[13]= base[2];
  997.     base[14]= VV[20];
  998.     base[15]= symbol_function(VV[77]);
  999.     base[16]= VV[22];
  1000.     base[17]= base[3];
  1001.     base[18]= VV[23];
  1002.     base[19]= base[4];
  1003.     base[20]= VV[25];
  1004.     base[21]= base[5];
  1005.     vs_top=(vs_base=base+10)+12;
  1006.     L23();
  1007.     return;
  1008. }
  1009. /*    function definition for COUNT-IF-NOT    */
  1010.  
  1011. static L25()
  1012. {    register object *base=vs_base;
  1013.     register object *sup=base+VM19;
  1014.     vs_reserve(VM19);
  1015.     if(vs_top-vs_base<2) too_few_arguments();
  1016.     parse_key(vs_base+2,FALSE,FALSE,4,VV[19],VV[22],VV[23],VV[25]);
  1017.     vs_top=sup;
  1018.     if(base[7]==Cnil){
  1019.     base[3]= VV[17];
  1020.     }else{}
  1021.     if(base[8]==Cnil){
  1022.     base[4]= make_fixnum(length(base[1]));
  1023.     }else{}
  1024.     if(base[9]==Cnil){
  1025.     base[5]= symbol_function(VV[76]);
  1026.     }else{}
  1027.     base[10]= base[0];
  1028.     base[11]= base[1];
  1029.     base[12]= VV[19];
  1030.     base[13]= base[2];
  1031.     base[14]= VV[21];
  1032.     base[15]= symbol_function(VV[77]);
  1033.     base[16]= VV[22];
  1034.     base[17]= base[3];
  1035.     base[18]= VV[23];
  1036.     base[19]= base[4];
  1037.     base[20]= VV[25];
  1038.     base[21]= base[5];
  1039.     vs_top=(vs_base=base+10)+12;
  1040.     L23();
  1041.     return;
  1042. }
  1043. /*    function definition for INTERNAL-COUNT    */
  1044.  
  1045. static L27()
  1046. {    register object *base=vs_base;
  1047.     register object *sup=base+VM20;
  1048.     vs_reserve(VM20);
  1049.     {int V71;
  1050.     if(vs_top-vs_base<2) too_few_arguments();
  1051.     parse_key(vs_base+2,FALSE,FALSE,7,VV[19],VV[20],VV[21],VV[22],VV[23],VV[24],VV[25]);
  1052.     vs_top=sup;
  1053.     if(base[12]==Cnil){
  1054.     base[5]= VV[17];
  1055.     }else{}
  1056.     if(base[13]==Cnil){
  1057.     base[6]= make_fixnum(length(base[1]));
  1058.     }else{}
  1059.     if(base[14]==Cnil){
  1060.     V71= length(base[1]);
  1061.     }else{
  1062.     V71=fix(base[7]);}
  1063.     if(base[15]==Cnil){
  1064.     base[8]= symbol_function(VV[76]);
  1065.     }else{}
  1066.     (void)(LI11(base[3],base[4],base[5],base[6]));
  1067.     {int V72;
  1068.     int V73;
  1069.     V72= fix(base[5]);
  1070.     V73= fix(base[6]);
  1071.     if((base[2])!=Cnil){
  1072.     goto T615;}
  1073.     {int V74;
  1074.     int V75;
  1075.     V74= V72;
  1076.     V75= 0;
  1077. T620:;
  1078.     if(!((V74)>=(V73))){
  1079.     goto T621;}
  1080.     base[16]= make_fixnum(V75);
  1081.     vs_top=(vs_base=base+16)+1;
  1082.     return;
  1083. T621:;
  1084.     if(!((V75)<(V71))){
  1085.     goto T625;}
  1086.     base[17]= elt(base[1],V74);
  1087.     vs_top=(vs_base=base+17)+1;
  1088.     super_funcall_no_event(base[8]);
  1089.     vs_top=sup;
  1090.     base[16]= vs_base[0];
  1091.     if((LI5(base[3],base[4],base[0],base[16]))==Cnil){
  1092.     goto T625;}
  1093.     V75= (V75)+1;
  1094. T625:;
  1095.     V74= (V74)+1;
  1096.     goto T620;}
  1097. T615:;
  1098.     {int V76;
  1099.     int V77;
  1100.     V76= (V73)-1;
  1101.     V77= 0;
  1102. T639:;
  1103.     if(!((V76)<(V72))){
  1104.     goto T640;}
  1105.     base[16]= make_fixnum(V77);
  1106.     vs_top=(vs_base=base+16)+1;
  1107.     return;
  1108. T640:;
  1109.     if(!((V77)<(V71))){
  1110.     goto T644;}
  1111.     base[17]= elt(base[1],V76);
  1112.     vs_top=(vs_base=base+17)+1;
  1113.     super_funcall_no_event(base[8]);
  1114.     vs_top=sup;
  1115.     base[16]= vs_base[0];
  1116.     if((LI5(base[3],base[4],base[0],base[16]))==Cnil){
  1117.     goto T644;}
  1118.     V77= (V77)+1;
  1119. T644:;
  1120.     V76= (V76)-1;
  1121.     goto T639;}}
  1122.     }
  1123. }
  1124. /*    function definition for INTERNAL-COUNT-IF    */
  1125.  
  1126. static L28()
  1127. {    register object *base=vs_base;
  1128.     register object *sup=base+VM21;
  1129.     vs_reserve(VM21);
  1130.     if(vs_top-vs_base<2) too_few_arguments();
  1131.     parse_key(vs_base+2,FALSE,FALSE,5,VV[19],VV[22],VV[23],VV[24],VV[25]);
  1132.     vs_top=sup;
  1133.     if(base[8]==Cnil){
  1134.     base[3]= VV[17];
  1135.     }else{}
  1136.     if(base[9]==Cnil){
  1137.     base[4]= make_fixnum(length(base[1]));
  1138.     }else{}
  1139.     if(base[10]==Cnil){
  1140.     base[5]= make_fixnum(length(base[1]));
  1141.     }else{}
  1142.     if(base[11]==Cnil){
  1143.     base[6]= symbol_function(VV[76]);
  1144.     }else{}
  1145.     base[12]= base[0];
  1146.     base[13]= base[1];
  1147.     base[14]= VV[19];
  1148.     base[15]= base[2];
  1149.     base[16]= VV[20];
  1150.     base[17]= symbol_function(VV[77]);
  1151.     base[18]= VV[22];
  1152.     base[19]= base[3];
  1153.     base[20]= VV[23];
  1154.     base[21]= base[4];
  1155.     base[22]= VV[24];
  1156.     base[23]= base[5];
  1157.     base[24]= VV[25];
  1158.     base[25]= base[6];
  1159.     vs_top=(vs_base=base+12)+14;
  1160.     L27();
  1161.     return;
  1162. }
  1163. /*    function definition for INTERNAL-COUNT-IF-NOT    */
  1164.  
  1165. static L29()
  1166. {    register object *base=vs_base;
  1167.     register object *sup=base+VM22;
  1168.     vs_reserve(VM22);
  1169.     if(vs_top-vs_base<2) too_few_arguments();
  1170.     parse_key(vs_base+2,FALSE,FALSE,5,VV[19],VV[22],VV[23],VV[24],VV[25]);
  1171.     vs_top=sup;
  1172.     if(base[8]==Cnil){
  1173.     base[3]= VV[17];
  1174.     }else{}
  1175.     if(base[9]==Cnil){
  1176.     base[4]= make_fixnum(length(base[1]));
  1177.     }else{}
  1178.     if(base[10]==Cnil){
  1179.     base[5]= make_fixnum(length(base[1]));
  1180.     }else{}
  1181.     if(base[11]==Cnil){
  1182.     base[6]= symbol_function(VV[76]);
  1183.     }else{}
  1184.     base[12]= base[0];
  1185.     base[13]= base[1];
  1186.     base[14]= VV[19];
  1187.     base[15]= base[2];
  1188.     base[16]= VV[21];
  1189.     base[17]= symbol_function(VV[77]);
  1190.     base[18]= VV[22];
  1191.     base[19]= base[3];
  1192.     base[20]= VV[23];
  1193.     base[21]= base[4];
  1194.     base[22]= VV[24];
  1195.     base[23]= base[5];
  1196.     base[24]= VV[25];
  1197.     base[25]= base[6];
  1198.     vs_top=(vs_base=base+12)+14;
  1199.     L27();
  1200.     return;
  1201. }
  1202. /*    function definition for SUBSTITUTE    */
  1203.  
  1204. static L31()
  1205. {    register object *base=vs_base;
  1206.     register object *sup=base+VM23;
  1207.     vs_reserve(VM23);
  1208.     {int V78;
  1209.     if(vs_top-vs_base<3) too_few_arguments();
  1210.     parse_key(vs_base+3,FALSE,FALSE,7,VV[19],VV[20],VV[21],VV[22],VV[23],VV[24],VV[25]);
  1211.     vs_top=sup;
  1212.     if(base[13]==Cnil){
  1213.     base[6]= VV[17];
  1214.     }else{}
  1215.     if(base[14]==Cnil){
  1216.     base[7]= make_fixnum(length(base[2]));
  1217.     }else{}
  1218.     if(base[15]==Cnil){
  1219.     V78= length(base[2]);
  1220.     }else{
  1221.     V78=fix(base[8]);}
  1222.     if(base[16]==Cnil){
  1223.     base[9]= symbol_function(VV[76]);
  1224.     }else{}
  1225.     {int V79;
  1226.     V79= length(base[2]);
  1227.     (void)(LI11(base[4],base[5],base[6],base[7]));
  1228.     {int V80;
  1229.     int V81;
  1230.     V80= fix(base[6]);
  1231.     V81= fix(base[7]);
  1232.     if((base[3])!=Cnil){
  1233.     goto T700;}
  1234.     {int V82;
  1235.     int V83;
  1236.     base[18]=symbol_function(VV[78]);
  1237.     base[19]= LI3(base[2]);
  1238.     base[20]= make_fixnum(V79);
  1239.     base[17]= simple_lispcall_no_event(base+18,2);
  1240.     V82= 0;
  1241.     V83= 0;
  1242. T708:;
  1243.     if(!((V82)>=(V79))){
  1244.     goto T709;}
  1245.     vs_top=(vs_base=base+17)+1;
  1246.     return;
  1247. T709:;
  1248.     if(!((V80)<=(V82))){
  1249.     goto T715;}
  1250.     if(!((V82)<(V81))){
  1251.     goto T715;}
  1252.     if(!((V83)<(V78))){
  1253.     goto T715;}
  1254.     base[19]= elt(base[2],V82);
  1255.     vs_top=(vs_base=base+19)+1;
  1256.     super_funcall_no_event(base[9]);
  1257.     vs_top=sup;
  1258.     base[18]= vs_base[0];
  1259.     if((LI5(base[4],base[5],base[1],base[18]))==Cnil){
  1260.     goto T715;}
  1261.     (void)(elt_set(base[17],V82,base[0]));
  1262.     V83= (V83)+1;
  1263.     goto T713;
  1264. T715:;
  1265.     base[18]= elt(base[2],V82);
  1266.     (void)(elt_set(base[17],V82,base[18]));
  1267. T713:;
  1268.     V82= (V82)+1;
  1269.     goto T708;}
  1270. T700:;
  1271.     {int V84;
  1272.     int V85;
  1273.     base[18]=symbol_function(VV[78]);
  1274.     base[19]= LI3(base[2]);
  1275.     base[20]= make_fixnum(V79);
  1276.     base[17]= simple_lispcall_no_event(base+18,2);
  1277.     V84= (V79)-1;
  1278.     V85= 0;
  1279. T736:;
  1280.     if(!((V84)<(0))){
  1281.     goto T737;}
  1282.     vs_top=(vs_base=base+17)+1;
  1283.     return;
  1284. T737:;
  1285.     if(!((V80)<=(V84))){
  1286.     goto T743;}
  1287.     if(!((V84)<(V81))){
  1288.     goto T743;}
  1289.     if(!((V85)<(V78))){
  1290.     goto T743;}
  1291.     base[19]= elt(base[2],V84);
  1292.     vs_top=(vs_base=base+19)+1;
  1293.     super_funcall_no_event(base[9]);
  1294.     vs_top=sup;
  1295.     base[18]= vs_base[0];
  1296.     if((LI5(base[4],base[5],base[1],base[18]))==Cnil){
  1297.     goto T743;}
  1298.     (void)(elt_set(base[17],V84,base[0]));
  1299.     V85= (V85)+1;
  1300.     goto T741;
  1301. T743:;
  1302.     base[18]= elt(base[2],V84);
  1303.     (void)(elt_set(base[17],V84,base[18]));
  1304. T741:;
  1305.     V84= (V84)-1;
  1306.     goto T736;}}}
  1307.     }
  1308. }
  1309. /*    function definition for SUBSTITUTE-IF    */
  1310.  
  1311. static L32()
  1312. {    register object *base=vs_base;
  1313.     register object *sup=base+VM24;
  1314.     vs_reserve(VM24);
  1315.     if(vs_top-vs_base<3) too_few_arguments();
  1316.     parse_key(vs_base+3,FALSE,FALSE,5,VV[19],VV[22],VV[23],VV[24],VV[25]);
  1317.     vs_top=sup;
  1318.     if(base[9]==Cnil){
  1319.     base[4]= VV[17];
  1320.     }else{}
  1321.     if(base[10]==Cnil){
  1322.     base[5]= make_fixnum(length(base[2]));
  1323.     }else{}
  1324.     if(base[11]==Cnil){
  1325.     base[6]= make_fixnum(length(base[2]));
  1326.     }else{}
  1327.     if(base[12]==Cnil){
  1328.     base[7]= symbol_function(VV[76]);
  1329.     }else{}
  1330.     base[13]= base[0];
  1331.     base[14]= base[1];
  1332.     base[15]= base[2];
  1333.     base[16]= VV[19];
  1334.     base[17]= base[3];
  1335.     base[18]= VV[20];
  1336.     base[19]= symbol_function(VV[77]);
  1337.     base[20]= VV[22];
  1338.     base[21]= base[4];
  1339.     base[22]= VV[23];
  1340.     base[23]= base[5];
  1341.     base[24]= VV[24];
  1342.     base[25]= base[6];
  1343.     base[26]= VV[25];
  1344.     base[27]= base[7];
  1345.     vs_top=(vs_base=base+13)+15;
  1346.     L31();
  1347.     return;
  1348. }
  1349. /*    function definition for SUBSTITUTE-IF-NOT    */
  1350.  
  1351. static L33()
  1352. {    register object *base=vs_base;
  1353.     register object *sup=base+VM25;
  1354.     vs_reserve(VM25);
  1355.     if(vs_top-vs_base<3) too_few_arguments();
  1356.     parse_key(vs_base+3,FALSE,FALSE,5,VV[19],VV[22],VV[23],VV[24],VV[25]);
  1357.     vs_top=sup;
  1358.     if(base[9]==Cnil){
  1359.     base[4]= VV[17];
  1360.     }else{}
  1361.     if(base[10]==Cnil){
  1362.     base[5]= make_fixnum(length(base[2]));
  1363.     }else{}
  1364.     if(base[11]==Cnil){
  1365.     base[6]= make_fixnum(length(base[2]));
  1366.     }else{}
  1367.     if(base[12]==Cnil){
  1368.     base[7]= symbol_function(VV[76]);
  1369.     }else{}
  1370.     base[13]= base[0];
  1371.     base[14]= base[1];
  1372.     base[15]= base[2];
  1373.     base[16]= VV[19];
  1374.     base[17]= base[3];
  1375.     base[18]= VV[21];
  1376.     base[19]= symbol_function(VV[77]);
  1377.     base[20]= VV[22];
  1378.     base[21]= base[4];
  1379.     base[22]= VV[23];
  1380.     base[23]= base[5];
  1381.     base[24]= VV[24];
  1382.     base[25]= base[6];
  1383.     base[26]= VV[25];
  1384.     base[27]= base[7];
  1385.     vs_top=(vs_base=base+13)+15;
  1386.     L31();
  1387.     return;
  1388. }
  1389. /*    function definition for NSUBSTITUTE    */
  1390.  
  1391. static L35()
  1392. {    register object *base=vs_base;
  1393.     register object *sup=base+VM26;
  1394.     vs_reserve(VM26);
  1395.     {int V86;
  1396.     if(vs_top-vs_base<3) too_few_arguments();
  1397.     parse_key(vs_base+3,FALSE,FALSE,7,VV[19],VV[20],VV[21],VV[22],VV[23],VV[24],VV[25]);
  1398.     vs_top=sup;
  1399.     if(base[13]==Cnil){
  1400.     base[6]= VV[17];
  1401.     }else{}
  1402.     if(base[14]==Cnil){
  1403.     base[7]= make_fixnum(length(base[2]));
  1404.     }else{}
  1405.     if(base[15]==Cnil){
  1406.     V86= length(base[2]);
  1407.     }else{
  1408.     V86=fix(base[8]);}
  1409.     if(base[16]==Cnil){
  1410.     base[9]= symbol_function(VV[76]);
  1411.     }else{}
  1412.     (void)(LI11(base[4],base[5],base[6],base[7]));
  1413.     {int V87;
  1414.     int V88;
  1415.     V87= fix(base[6]);
  1416.     V88= fix(base[7]);
  1417.     if((base[3])!=Cnil){
  1418.     goto T804;}
  1419.     {int V89;
  1420.     int V90;
  1421.     V89= V87;
  1422.     V90= 0;
  1423. T809:;
  1424.     if(!((V89)>=(V88))){
  1425.     goto T810;}
  1426.     vs_top=(vs_base=base+2)+1;
  1427.     return;
  1428. T810:;
  1429.     if(!((V90)<(V86))){
  1430.     goto T814;}
  1431.     base[18]= elt(base[2],V89);
  1432.     vs_top=(vs_base=base+18)+1;
  1433.     super_funcall_no_event(base[9]);
  1434.     vs_top=sup;
  1435.     base[17]= vs_base[0];
  1436.     if((LI5(base[4],base[5],base[1],base[17]))==Cnil){
  1437.     goto T814;}
  1438.     (void)(elt_set(base[2],V89,base[0]));
  1439.     V90= (V90)+1;
  1440. T814:;
  1441.     V89= (V89)+1;
  1442.     goto T809;}
  1443. T804:;
  1444.     {int V91;
  1445.     int V92;
  1446.     V91= (V88)-1;
  1447.     V92= 0;
  1448. T829:;
  1449.     if(!((V91)<(V87))){
  1450.     goto T830;}
  1451.     vs_top=(vs_base=base+2)+1;
  1452.     return;
  1453. T830:;
  1454.     if(!((V92)<(V86))){
  1455.     goto T834;}
  1456.     base[18]= elt(base[2],V91);
  1457.     vs_top=(vs_base=base+18)+1;
  1458.     super_funcall_no_event(base[9]);
  1459.     vs_top=sup;
  1460.     base[17]= vs_base[0];
  1461.     if((LI5(base[4],base[5],base[1],base[17]))==Cnil){
  1462.     goto T834;}
  1463.     (void)(elt_set(base[2],V91,base[0]));
  1464.     V92= (V92)+1;
  1465. T834:;
  1466.     V91= (V91)-1;
  1467.     goto T829;}}
  1468.     }
  1469. }
  1470. /*    function definition for NSUBSTITUTE-IF    */
  1471.  
  1472. static L36()
  1473. {    register object *base=vs_base;
  1474.     register object *sup=base+VM27;
  1475.     vs_reserve(VM27);
  1476.     if(vs_top-vs_base<3) too_few_arguments();
  1477.     parse_key(vs_base+3,FALSE,FALSE,5,VV[19],VV[22],VV[23],VV[24],VV[25]);
  1478.     vs_top=sup;
  1479.     if(base[9]==Cnil){
  1480.     base[4]= VV[17];
  1481.     }else{}
  1482.     if(base[10]==Cnil){
  1483.     base[5]= make_fixnum(length(base[2]));
  1484.     }else{}
  1485.     if(base[11]==Cnil){
  1486.     base[6]= make_fixnum(length(base[2]));
  1487.     }else{}
  1488.     if(base[12]==Cnil){
  1489.     base[7]= symbol_function(VV[76]);
  1490.     }else{}
  1491.     base[13]= base[0];
  1492.     base[14]= base[1];
  1493.     base[15]= base[2];
  1494.     base[16]= VV[19];
  1495.     base[17]= base[3];
  1496.     base[18]= VV[20];
  1497.     base[19]= symbol_function(VV[77]);
  1498.     base[20]= VV[22];
  1499.     base[21]= base[4];
  1500.     base[22]= VV[23];
  1501.     base[23]= base[5];
  1502.     base[24]= VV[24];
  1503.     base[25]= base[6];
  1504.     base[26]= VV[25];
  1505.     base[27]= base[7];
  1506.     vs_top=(vs_base=base+13)+15;
  1507.     L35();
  1508.     return;
  1509. }
  1510. /*    function definition for NSUBSTITUTE-IF-NOT    */
  1511.  
  1512. static L37()
  1513. {    register object *base=vs_base;
  1514.     register object *sup=base+VM28;
  1515.     vs_reserve(VM28);
  1516.     if(vs_top-vs_base<3) too_few_arguments();
  1517.     parse_key(vs_base+3,FALSE,FALSE,5,VV[19],VV[22],VV[23],VV[24],VV[25]);
  1518.     vs_top=sup;
  1519.     if(base[9]==Cnil){
  1520.     base[4]= VV[17];
  1521.     }else{}
  1522.     if(base[10]==Cnil){
  1523.     base[5]= make_fixnum(length(base[2]));
  1524.     }else{}
  1525.     if(base[11]==Cnil){
  1526.     base[6]= make_fixnum(length(base[2]));
  1527.     }else{}
  1528.     if(base[12]==Cnil){
  1529.     base[7]= symbol_function(VV[76]);
  1530.     }else{}
  1531.     base[13]= base[0];
  1532.     base[14]= base[1];
  1533.     base[15]= base[2];
  1534.     base[16]= VV[19];
  1535.     base[17]= base[3];
  1536.     base[18]= VV[21];
  1537.     base[19]= symbol_function(VV[77]);
  1538.     base[20]= VV[22];
  1539.     base[21]= base[4];
  1540.     base[22]= VV[23];
  1541.     base[23]= base[5];
  1542.     base[24]= VV[24];
  1543.     base[25]= base[6];
  1544.     base[26]= VV[25];
  1545.     base[27]= base[7];
  1546.     vs_top=(vs_base=base+13)+15;
  1547.     L35();
  1548.     return;
  1549. }
  1550. /*    function definition for FIND    */
  1551.  
  1552. static L39()
  1553. {    register object *base=vs_base;
  1554.     register object *sup=base+VM29;
  1555.     vs_reserve(VM29);
  1556.     if(vs_top-vs_base<2) too_few_arguments();
  1557.     parse_key(vs_base+2,FALSE,FALSE,6,VV[19],VV[20],VV[21],VV[22],VV[23],VV[25]);
  1558.     vs_top=sup;
  1559.     if(base[11]==Cnil){
  1560.     base[5]= VV[17];
  1561.     }else{}
  1562.     if(base[12]==Cnil){
  1563.     base[6]= make_fixnum(length(base[1]));
  1564.     }else{}
  1565.     if(base[13]==Cnil){
  1566.     base[7]= symbol_function(VV[76]);
  1567.     }else{}
  1568.     (void)(LI11(base[3],base[4],base[5],base[6]));
  1569.     {int V93;
  1570.     int V94;
  1571.     V93= fix(base[5]);
  1572.     V94= fix(base[6]);
  1573.     if((base[2])!=Cnil){
  1574.     goto T891;}
  1575.     {int V95;
  1576.     V95= V93;
  1577. T895:;
  1578.     if(!((V95)>=(V94))){
  1579.     goto T896;}
  1580.     base[14]= Cnil;
  1581.     vs_top=(vs_base=base+14)+1;
  1582.     return;
  1583. T896:;
  1584.     base[15]= elt(base[1],V95);
  1585.     vs_top=(vs_base=base+15)+1;
  1586.     super_funcall_no_event(base[7]);
  1587.     vs_top=sup;
  1588.     base[14]= vs_base[0];
  1589.     if((LI5(base[3],base[4],base[0],base[14]))==Cnil){
  1590.     goto T900;}
  1591.     base[14]= elt(base[1],V95);
  1592.     vs_top=(vs_base=base+14)+1;
  1593.     return;
  1594. T900:;
  1595.     V95= (V95)+1;
  1596.     goto T895;}
  1597. T891:;
  1598.     {int V96;
  1599.     V96= (V94)-1;
  1600. T910:;
  1601.     if(!((V96)<(V93))){
  1602.     goto T911;}
  1603.     base[14]= Cnil;
  1604.     vs_top=(vs_base=base+14)+1;
  1605.     return;
  1606. T911:;
  1607.     base[15]= elt(base[1],V96);
  1608.     vs_top=(vs_base=base+15)+1;
  1609.     super_funcall_no_event(base[7]);
  1610.     vs_top=sup;
  1611.     base[14]= vs_base[0];
  1612.     if((LI5(base[3],base[4],base[0],base[14]))==Cnil){
  1613.     goto T915;}
  1614.     base[14]= elt(base[1],V96);
  1615.     vs_top=(vs_base=base+14)+1;
  1616.     return;
  1617. T915:;
  1618.     V96= (V96)-1;
  1619.     goto T910;}}
  1620. }
  1621. /*    function definition for FIND-IF    */
  1622.  
  1623. static L40()
  1624. {    register object *base=vs_base;
  1625.     register object *sup=base+VM30;
  1626.     vs_reserve(VM30);
  1627.     if(vs_top-vs_base<2) too_few_arguments();
  1628.     parse_key(vs_base+2,FALSE,FALSE,4,VV[19],VV[22],VV[23],VV[25]);
  1629.     vs_top=sup;
  1630.     if(base[7]==Cnil){
  1631.     base[3]= VV[17];
  1632.     }else{}
  1633.     if(base[8]==Cnil){
  1634.     base[4]= make_fixnum(length(base[1]));
  1635.     }else{}
  1636.     if(base[9]==Cnil){
  1637.     base[5]= symbol_function(VV[76]);
  1638.     }else{}
  1639.     base[10]= base[0];
  1640.     base[11]= base[1];
  1641.     base[12]= VV[19];
  1642.     base[13]= base[2];
  1643.     base[14]= VV[20];
  1644.     base[15]= symbol_function(VV[77]);
  1645.     base[16]= VV[22];
  1646.     base[17]= base[3];
  1647.     base[18]= VV[23];
  1648.     base[19]= base[4];
  1649.     base[20]= VV[25];
  1650.     base[21]= base[5];
  1651.     vs_top=(vs_base=base+10)+12;
  1652.     L39();
  1653.     return;
  1654. }
  1655. /*    function definition for FIND-IF-NOT    */
  1656.  
  1657. static L41()
  1658. {    register object *base=vs_base;
  1659.     register object *sup=base+VM31;
  1660.     vs_reserve(VM31);
  1661.     if(vs_top-vs_base<2) too_few_arguments();
  1662.     parse_key(vs_base+2,FALSE,FALSE,4,VV[19],VV[22],VV[23],VV[25]);
  1663.     vs_top=sup;
  1664.     if(base[7]==Cnil){
  1665.     base[3]= VV[17];
  1666.     }else{}
  1667.     if(base[8]==Cnil){
  1668.     base[4]= make_fixnum(length(base[1]));
  1669.     }else{}
  1670.     if(base[9]==Cnil){
  1671.     base[5]= symbol_function(VV[76]);
  1672.     }else{}
  1673.     base[10]= base[0];
  1674.     base[11]= base[1];
  1675.     base[12]= VV[19];
  1676.     base[13]= base[2];
  1677.     base[14]= VV[21];
  1678.     base[15]= symbol_function(VV[77]);
  1679.     base[16]= VV[22];
  1680.     base[17]= base[3];
  1681.     base[18]= VV[23];
  1682.     base[19]= base[4];
  1683.     base[20]= VV[25];
  1684.     base[21]= base[5];
  1685.     vs_top=(vs_base=base+10)+12;
  1686.     L39();
  1687.     return;
  1688. }
  1689. /*    function definition for POSITION    */
  1690.  
  1691. static L43()
  1692. {    register object *base=vs_base;
  1693.     register object *sup=base+VM32;
  1694.     vs_reserve(VM32);
  1695.     if(vs_top-vs_base<2) too_few_arguments();
  1696.     parse_key(vs_base+2,FALSE,FALSE,6,VV[19],VV[20],VV[21],VV[22],VV[23],VV[25]);
  1697.     vs_top=sup;
  1698.     if(base[11]==Cnil){
  1699.     base[5]= VV[17];
  1700.     }else{}
  1701.     if(base[12]==Cnil){
  1702.     base[6]= make_fixnum(length(base[1]));
  1703.     }else{}
  1704.     if(base[13]==Cnil){
  1705.     base[7]= symbol_function(VV[76]);
  1706.     }else{}
  1707.     (void)(LI11(base[3],base[4],base[5],base[6]));
  1708.     {int V97;
  1709.     int V98;
  1710.     V97= fix(base[5]);
  1711.     V98= fix(base[6]);
  1712.     if((base[2])!=Cnil){
  1713.     goto T960;}
  1714.     {int V99;
  1715.     V99= V97;
  1716. T964:;
  1717.     if(!((V99)>=(V98))){
  1718.     goto T965;}
  1719.     base[14]= Cnil;
  1720.     vs_top=(vs_base=base+14)+1;
  1721.     return;
  1722. T965:;
  1723.     base[15]= elt(base[1],V99);
  1724.     vs_top=(vs_base=base+15)+1;
  1725.     super_funcall_no_event(base[7]);
  1726.     vs_top=sup;
  1727.     base[14]= vs_base[0];
  1728.     if((LI5(base[3],base[4],base[0],base[14]))==Cnil){
  1729.     goto T969;}
  1730.     base[14]= make_fixnum(V99);
  1731.     vs_top=(vs_base=base+14)+1;
  1732.     return;
  1733. T969:;
  1734.     V99= (V99)+1;
  1735.     goto T964;}
  1736. T960:;
  1737.     {int V100;
  1738.     V100= (V98)-1;
  1739. T979:;
  1740.     if(!((V100)<(V97))){
  1741.     goto T980;}
  1742.     base[14]= Cnil;
  1743.     vs_top=(vs_base=base+14)+1;
  1744.     return;
  1745. T980:;
  1746.     base[15]= elt(base[1],V100);
  1747.     vs_top=(vs_base=base+15)+1;
  1748.     super_funcall_no_event(base[7]);
  1749.     vs_top=sup;
  1750.     base[14]= vs_base[0];
  1751.     if((LI5(base[3],base[4],base[0],base[14]))==Cnil){
  1752.     goto T984;}
  1753.     base[14]= make_fixnum(V100);
  1754.     vs_top=(vs_base=base+14)+1;
  1755.     return;
  1756. T984:;
  1757.     V100= (V100)-1;
  1758.     goto T979;}}
  1759. }
  1760. /*    function definition for POSITION-IF    */
  1761.  
  1762. static L44()
  1763. {    register object *base=vs_base;
  1764.     register object *sup=base+VM33;
  1765.     vs_reserve(VM33);
  1766.     if(vs_top-vs_base<2) too_few_arguments();
  1767.     parse_key(vs_base+2,FALSE,FALSE,4,VV[19],VV[22],VV[23],VV[25]);
  1768.     vs_top=sup;
  1769.     if(base[7]==Cnil){
  1770.     base[3]= VV[17];
  1771.     }else{}
  1772.     if(base[8]==Cnil){
  1773.     base[4]= make_fixnum(length(base[1]));
  1774.     }else{}
  1775.     if(base[9]==Cnil){
  1776.     base[5]= symbol_function(VV[76]);
  1777.     }else{}
  1778.     base[10]= base[0];
  1779.     base[11]= base[1];
  1780.     base[12]= VV[19];
  1781.     base[13]= base[2];
  1782.     base[14]= VV[20];
  1783.     base[15]= symbol_function(VV[77]);
  1784.     base[16]= VV[22];
  1785.     base[17]= base[3];
  1786.     base[18]= VV[23];
  1787.     base[19]= base[4];
  1788.     base[20]= VV[25];
  1789.     base[21]= base[5];
  1790.     vs_top=(vs_base=base+10)+12;
  1791.     L43();
  1792.     return;
  1793. }
  1794. /*    function definition for POSITION-IF-NOT    */
  1795.  
  1796. static L45()
  1797. {    register object *base=vs_base;
  1798.     register object *sup=base+VM34;
  1799.     vs_reserve(VM34);
  1800.     if(vs_top-vs_base<2) too_few_arguments();
  1801.     parse_key(vs_base+2,FALSE,FALSE,4,VV[19],VV[22],VV[23],VV[25]);
  1802.     vs_top=sup;
  1803.     if(base[7]==Cnil){
  1804.     base[3]= VV[17];
  1805.     }else{}
  1806.     if(base[8]==Cnil){
  1807.     base[4]= make_fixnum(length(base[1]));
  1808.     }else{}
  1809.     if(base[9]==Cnil){
  1810.     base[5]= symbol_function(VV[76]);
  1811.     }else{}
  1812.     base[10]= base[0];
  1813.     base[11]= base[1];
  1814.     base[12]= VV[19];
  1815.     base[13]= base[2];
  1816.     base[14]= VV[21];
  1817.     base[15]= symbol_function(VV[77]);
  1818.     base[16]= VV[22];
  1819.     base[17]= base[3];
  1820.     base[18]= VV[23];
  1821.     base[19]= base[4];
  1822.     base[20]= VV[25];
  1823.     base[21]= base[5];
  1824.     vs_top=(vs_base=base+10)+12;
  1825.     L43();
  1826.     return;
  1827. }
  1828. /*    function definition for REMOVE-DUPLICATES    */
  1829.  
  1830. static L47()
  1831. {    register object *base=vs_base;
  1832.     register object *sup=base+VM35;
  1833.     vs_reserve(VM35);
  1834.     if(vs_top-vs_base<1) too_few_arguments();
  1835.     parse_key(vs_base+1,FALSE,FALSE,6,VV[19],VV[20],VV[21],VV[22],VV[23],VV[25]);
  1836.     vs_top=sup;
  1837.     if(base[10]==Cnil){
  1838.     base[4]= VV[17];
  1839.     }else{}
  1840.     if(base[11]==Cnil){
  1841.     base[5]= make_fixnum(length(base[0]));
  1842.     }else{}
  1843.     if(base[12]==Cnil){
  1844.     base[6]= symbol_function(VV[76]);
  1845.     }else{}
  1846.     (void)(LI11(base[2],base[3],base[4],base[5]));
  1847.     if(!(type_of(base[0])==t_cons||base[0]==Cnil)){
  1848.     goto T1026;}
  1849.     if((base[1])!=Cnil){
  1850.     goto T1026;}
  1851.     if((base[10])!=Cnil){
  1852.     goto T1026;}
  1853.     if((base[11])!=Cnil){
  1854.     goto T1026;}
  1855.     if(!(endp(base[0]))){
  1856.     goto T1035;}
  1857.     base[13]= Cnil;
  1858.     vs_top=(vs_base=base+13)+1;
  1859.     return;
  1860. T1035:;
  1861.     base[13]= base[0];
  1862.     base[14]= Cnil;
  1863. T1039:;
  1864.     if(!(endp(cdr(base[13])))){
  1865.     goto T1040;}
  1866.     base[15]= base[14];
  1867.     base[16]= base[13];
  1868.     vs_top=(vs_base=base+15)+2;
  1869.     Lreconc();
  1870.     return;
  1871. T1040:;
  1872.     base[15]= car(base[13]);
  1873.     base[16]= cdr(base[13]);
  1874.     base[17]= VV[20];
  1875.     base[18]= base[2];
  1876.     base[19]= VV[21];
  1877.     base[20]= base[3];
  1878.     base[21]= VV[25];
  1879.     base[22]= base[6];
  1880.     if((simple_symlispcall_no_event(VV[79],base+15,8))!=Cnil){
  1881.     goto T1046;}
  1882.     base[14]= make_cons(car(base[13]),base[14]);
  1883. T1046:;
  1884.     base[13]= cdr(base[13]);
  1885.     goto T1039;
  1886. T1026:;
  1887.     base[13]= base[0];
  1888.     base[14]= VV[19];
  1889.     base[15]= base[1];
  1890.     base[16]= VV[20];
  1891.     base[17]= base[2];
  1892.     base[18]= VV[21];
  1893.     base[19]= base[3];
  1894.     base[20]= VV[22];
  1895.     base[21]= base[4];
  1896.     base[22]= VV[23];
  1897.     base[23]= base[5];
  1898.     base[24]= VV[25];
  1899.     base[25]= base[6];
  1900.     vs_top=(vs_base=base+13)+13;
  1901.     L48();
  1902.     return;
  1903. }
  1904. /*    function definition for DELETE-DUPLICATES    */
  1905.  
  1906. static L48()
  1907. {    register object *base=vs_base;
  1908.     register object *sup=base+VM36;
  1909.     vs_reserve(VM36);
  1910.     if(vs_top-vs_base<1) too_few_arguments();
  1911.     parse_key(vs_base+1,FALSE,FALSE,6,VV[19],VV[20],VV[21],VV[22],VV[23],VV[25]);
  1912.     vs_top=sup;
  1913.     if(base[10]==Cnil){
  1914.     base[4]= VV[17];
  1915.     }else{}
  1916.     if(base[11]==Cnil){
  1917.     base[5]= make_fixnum(length(base[0]));
  1918.     }else{}
  1919.     if(base[12]==Cnil){
  1920.     base[6]= symbol_function(VV[76]);
  1921.     }else{}
  1922.     {int V101;
  1923.     V101= length(base[0]);
  1924.     (void)(LI11(base[2],base[3],base[4],base[5]));
  1925.     if(!(type_of(base[0])==t_cons||base[0]==Cnil)){
  1926.     goto T1079;}
  1927.     if((base[1])!=Cnil){
  1928.     goto T1079;}
  1929.     if((base[10])!=Cnil){
  1930.     goto T1079;}
  1931.     if((base[11])!=Cnil){
  1932.     goto T1079;}
  1933.     if(!(endp(base[0]))){
  1934.     goto T1088;}
  1935.     base[13]= Cnil;
  1936.     vs_top=(vs_base=base+13)+1;
  1937.     return;
  1938. T1088:;
  1939.     base[13]= base[0];
  1940. T1092:;
  1941.     if(!(endp(cdr(base[13])))){
  1942.     goto T1093;}
  1943.     vs_top=(vs_base=base+0)+1;
  1944.     return;
  1945. T1093:;
  1946.     base[14]= car(base[13]);
  1947.     base[15]= cdr(base[13]);
  1948.     base[16]= VV[20];
  1949.     base[17]= base[2];
  1950.     base[18]= VV[21];
  1951.     base[19]= base[3];
  1952.     base[20]= VV[25];
  1953.     base[21]= base[6];
  1954.     if((simple_symlispcall_no_event(VV[79],base+14,8))==Cnil){
  1955.     goto T1099;}
  1956.     if(type_of(base[13])!=t_cons)FEwrong_type_argument(Scons,base[13]);
  1957.     (base[13])->c.c_car = cadr(base[13]);
  1958.     if(type_of(base[13])!=t_cons)FEwrong_type_argument(Scons,base[13]);
  1959.     (base[13])->c.c_cdr = cddr(base[13]);
  1960.     goto T1097;
  1961. T1099:;
  1962.     base[13]= cdr(base[13]);
  1963. T1097:;
  1964.     goto T1092;
  1965. T1079:;
  1966.     {int V102;
  1967.     int V103;
  1968.     V102= fix(base[4]);
  1969.     V103= fix(base[5]);
  1970.     if((base[1])!=Cnil){
  1971.     goto T1116;}
  1972.     {int V104;
  1973.     int V105;
  1974.     V104= 0;
  1975.     V105= V102;
  1976. T1121:;
  1977.     if(!((V105)>=(V103))){
  1978.     goto T1122;}
  1979.     {int V106;
  1980.     int V107;
  1981.     base[14]=symbol_function(VV[78]);
  1982.     base[15]= LI3(base[0]);
  1983.     base[16]= make_fixnum((V101)-(V104));
  1984.     base[13]= simple_lispcall_no_event(base+14,2);
  1985.     V106= 0;
  1986.     V107= 0;
  1987. T1131:;
  1988.     if(!((V106)>=(V101))){
  1989.     goto T1132;}
  1990.     vs_top=(vs_base=base+13)+1;
  1991.     return;
  1992. T1132:;
  1993.     if((V102)<=(V106)){
  1994.     goto T1138;}
  1995.     base[14]= Cnil;
  1996.     goto T1137;
  1997. T1138:;
  1998.     if((V106)<(V103)){
  1999.     goto T1140;}
  2000.     base[14]= Cnil;
  2001.     goto T1137;
  2002. T1140:;
  2003.     base[16]= elt(base[0],V106);
  2004.     vs_top=(vs_base=base+16)+1;
  2005.     super_funcall_no_event(base[6]);
  2006.     vs_top=sup;
  2007.     base[15]= vs_base[0];
  2008.     base[16]= base[0];
  2009.     base[17]= VV[20];
  2010.     base[18]= base[2];
  2011.     base[19]= VV[21];
  2012.     base[20]= base[3];
  2013.     base[21]= VV[22];
  2014.     base[22]= make_fixnum((V106)+1);
  2015.     base[23]= VV[23];
  2016.     base[24]= make_fixnum(V103);
  2017.     base[25]= VV[25];
  2018.     base[26]= base[6];
  2019.     vs_top=(vs_base=base+15)+12;
  2020.     L43();
  2021.     vs_top=sup;
  2022.     base[14]= vs_base[0];
  2023. T1137:;
  2024.     if((base[14])==Cnil){
  2025.     goto T1156;}
  2026.     goto T1136;
  2027. T1156:;
  2028.     base[15]= elt(base[0],V106);
  2029.     (void)(elt_set(base[13],V107,base[15]));
  2030.     V107= (V107)+(1);
  2031. T1136:;
  2032.     V106= (V106)+1;
  2033.     goto T1131;}
  2034. T1122:;
  2035.     base[14]= elt(base[0],V105);
  2036.     vs_top=(vs_base=base+14)+1;
  2037.     super_funcall_no_event(base[6]);
  2038.     vs_top=sup;
  2039.     base[13]= vs_base[0];
  2040.     base[14]= base[0];
  2041.     base[15]= VV[20];
  2042.     base[16]= base[2];
  2043.     base[17]= VV[21];
  2044.     base[18]= base[3];
  2045.     base[19]= VV[22];
  2046.     base[20]= make_fixnum((V105)+1);
  2047.     base[21]= VV[23];
  2048.     base[22]= make_fixnum(V103);
  2049.     base[23]= VV[25];
  2050.     base[24]= base[6];
  2051.     vs_top=(vs_base=base+13)+12;
  2052.     L43();
  2053.     vs_top=sup;
  2054.     if((vs_base[0])==Cnil){
  2055.     goto T1164;}
  2056.     V104= (V104)+(1);
  2057. T1164:;
  2058.     V105= (V105)+1;
  2059.     goto T1121;}
  2060. T1116:;
  2061.     {int V108;
  2062.     int V109;
  2063.     V108= 0;
  2064.     V109= (V103)-1;
  2065. T1187:;
  2066.     if(!((V109)<(V102))){
  2067.     goto T1188;}
  2068.     {int V110;
  2069.     int V111;
  2070.     base[14]=symbol_function(VV[78]);
  2071.     base[15]= LI3(base[0]);
  2072.     base[16]= make_fixnum((V101)-(V108));
  2073.     base[13]= simple_lispcall_no_event(base+14,2);
  2074.     V110= (V101)-1;
  2075.     V111= ((V101)-1)-(V108);
  2076. T1197:;
  2077.     if(!((V110)<(0))){
  2078.     goto T1198;}
  2079.     vs_top=(vs_base=base+13)+1;
  2080.     return;
  2081. T1198:;
  2082.     if((V102)<=(V110)){
  2083.     goto T1204;}
  2084.     base[14]= Cnil;
  2085.     goto T1203;
  2086. T1204:;
  2087.     if((V110)<(V103)){
  2088.     goto T1206;}
  2089.     base[14]= Cnil;
  2090.     goto T1203;
  2091. T1206:;
  2092.     base[16]= elt(base[0],V110);
  2093.     vs_top=(vs_base=base+16)+1;
  2094.     super_funcall_no_event(base[6]);
  2095.     vs_top=sup;
  2096.     base[15]= vs_base[0];
  2097.     base[16]= base[0];
  2098.     base[17]= VV[19];
  2099.     base[18]= Ct;
  2100.     base[19]= VV[20];
  2101.     base[20]= base[2];
  2102.     base[21]= VV[21];
  2103.     base[22]= base[3];
  2104.     base[23]= VV[22];
  2105.     base[24]= make_fixnum(V102);
  2106.     base[25]= VV[23];
  2107.     base[26]= make_fixnum(V110);
  2108.     base[27]= VV[25];
  2109.     base[28]= base[6];
  2110.     vs_top=(vs_base=base+15)+14;
  2111.     L43();
  2112.     vs_top=sup;
  2113.     base[14]= vs_base[0];
  2114. T1203:;
  2115.     if((base[14])==Cnil){
  2116.     goto T1224;}
  2117.     goto T1202;
  2118. T1224:;
  2119.     base[15]= elt(base[0],V110);
  2120.     (void)(elt_set(base[13],V111,base[15]));
  2121.     V111= (V111)-(1);
  2122. T1202:;
  2123.     V110= (V110)-1;
  2124.     goto T1197;}
  2125. T1188:;
  2126.     base[14]= elt(base[0],V109);
  2127.     vs_top=(vs_base=base+14)+1;
  2128.     super_funcall_no_event(base[6]);
  2129.     vs_top=sup;
  2130.     base[13]= vs_base[0];
  2131.     base[14]= base[0];
  2132.     base[15]= VV[19];
  2133.     base[16]= Ct;
  2134.     base[17]= VV[20];
  2135.     base[18]= base[2];
  2136.     base[19]= VV[21];
  2137.     base[20]= base[3];
  2138.     base[21]= VV[22];
  2139.     base[22]= make_fixnum(V102);
  2140.     base[23]= VV[23];
  2141.     base[24]= make_fixnum(V109);
  2142.     base[25]= VV[25];
  2143.     base[26]= base[6];
  2144.     vs_top=(vs_base=base+13)+14;
  2145.     L43();
  2146.     vs_top=sup;
  2147.     if((vs_base[0])==Cnil){
  2148.     goto T1232;}
  2149.     V108= (V108)+(1);
  2150. T1232:;
  2151.     V109= (V109)-1;
  2152.     goto T1187;}}}
  2153. }
  2154. /*    function definition for MISMATCH    */
  2155.  
  2156. static L49()
  2157. {    register object *base=vs_base;
  2158.     register object *sup=base+VM37;
  2159.     vs_reserve(VM37);
  2160.     if(vs_top-vs_base<2) too_few_arguments();
  2161.     parse_key(vs_base+2,FALSE,FALSE,8,VV[19],VV[20],VV[21],VV[25],VV[72],VV[74],VV[73],VV[75]);
  2162.     vs_top=sup;
  2163.     if(base[13]==Cnil){
  2164.     base[5]= symbol_function(VV[76]);
  2165.     }else{}
  2166.     if(base[14]==Cnil){
  2167.     base[6]= VV[17];
  2168.     }else{}
  2169.     if(base[15]==Cnil){
  2170.     base[7]= VV[17];
  2171.     }else{}
  2172.     if(base[16]==Cnil){
  2173.     base[8]= make_fixnum(length(base[0]));
  2174.     }else{}
  2175.     if(base[17]==Cnil){
  2176.     base[9]= make_fixnum(length(base[1]));
  2177.     }else{}
  2178.     (void)(LI7(base[3],base[4]));
  2179.     (void)(LI9(base[6],base[8]));
  2180.     (void)(LI9(base[7],base[9]));
  2181.     {int V112;
  2182.     int V113;
  2183.     int V114;
  2184.     int V115;
  2185.     V112= fix(base[6]);
  2186.     V113= fix(base[8]);
  2187.     V114= fix(base[7]);
  2188.     V115= fix(base[9]);
  2189.     if((base[2])!=Cnil){
  2190.     goto T1267;}
  2191.     {int V116;
  2192.     int V117;
  2193.     V116= V112;
  2194.     V117= V114;
  2195. T1272:;
  2196.     if((V116)>=(V113)){
  2197.     goto T1274;}
  2198.     if(!((V117)>=(V115))){
  2199.     goto T1273;}
  2200. T1274:;
  2201.     if(!((V116)>=(V113))){
  2202.     goto T1279;}
  2203.     if(!((V117)>=(V115))){
  2204.     goto T1279;}
  2205.     base[18]= Cnil;
  2206.     vs_top=(vs_base=base+18)+1;
  2207.     return;
  2208. T1279:;
  2209.     base[18]= make_fixnum(V116);
  2210.     vs_top=(vs_base=base+18)+1;
  2211.     return;
  2212. T1273:;
  2213.     base[19]= elt(base[0],V116);
  2214.     vs_top=(vs_base=base+19)+1;
  2215.     super_funcall_no_event(base[5]);
  2216.     vs_top=sup;
  2217.     base[18]= vs_base[0];
  2218.     base[20]= elt(base[1],V117);
  2219.     vs_top=(vs_base=base+20)+1;
  2220.     super_funcall_no_event(base[5]);
  2221.     vs_top=sup;
  2222.     base[19]= vs_base[0];
  2223.     if((LI5(base[3],base[4],base[18],base[19]))!=Cnil){
  2224.     goto T1284;}
  2225.     base[18]= make_fixnum(V116);
  2226.     vs_top=(vs_base=base+18)+1;
  2227.     return;
  2228. T1284:;
  2229.     V116= (V116)+1;
  2230.     V117= (V117)+1;
  2231.     goto T1272;}
  2232. T1267:;
  2233.     {int V118;
  2234.     int V119;
  2235.     V118= (V113)-1;
  2236.     V119= (V115)-1;
  2237. T1298:;
  2238.     if((V118)<(V112)){
  2239.     goto T1300;}
  2240.     if(!((V119)<(V114))){
  2241.     goto T1299;}
  2242. T1300:;
  2243.     if(!((V118)<(V112))){
  2244.     goto T1305;}
  2245.     if(!((V119)<(V114))){
  2246.     goto T1305;}
  2247.     base[18]= Cnil;
  2248.     vs_top=(vs_base=base+18)+1;
  2249.     return;
  2250. T1305:;
  2251.     base[18]= make_fixnum(V118);
  2252.     vs_top=(vs_base=base+18)+1;
  2253.     return;
  2254. T1299:;
  2255.     base[19]= elt(base[0],V118);
  2256.     vs_top=(vs_base=base+19)+1;
  2257.     super_funcall_no_event(base[5]);
  2258.     vs_top=sup;
  2259.     base[18]= vs_base[0];
  2260.     base[20]= elt(base[1],V119);
  2261.     vs_top=(vs_base=base+20)+1;
  2262.     super_funcall_no_event(base[5]);
  2263.     vs_top=sup;
  2264.     base[19]= vs_base[0];
  2265.     if((LI5(base[3],base[4],base[18],base[19]))!=Cnil){
  2266.     goto T1310;}
  2267.     base[18]= make_fixnum(V118);
  2268.     vs_top=(vs_base=base+18)+1;
  2269.     return;
  2270. T1310:;
  2271.     V118= (V118)-1;
  2272.     V119= (V119)-1;
  2273.     goto T1298;}}
  2274. }
  2275. /*    function definition for SEARCH    */
  2276.  
  2277. static L50()
  2278. {    register object *base=vs_base;
  2279.     register object *sup=base+VM38;
  2280.     vs_reserve(VM38);
  2281.     if(vs_top-vs_base<2) too_few_arguments();
  2282.     parse_key(vs_base+2,FALSE,FALSE,8,VV[19],VV[20],VV[21],VV[25],VV[72],VV[74],VV[73],VV[75]);
  2283.     vs_top=sup;
  2284.     if(base[13]==Cnil){
  2285.     base[5]= symbol_function(VV[76]);
  2286.     }else{}
  2287.     if(base[14]==Cnil){
  2288.     base[6]= VV[17];
  2289.     }else{}
  2290.     if(base[15]==Cnil){
  2291.     base[7]= VV[17];
  2292.     }else{}
  2293.     if(base[16]==Cnil){
  2294.     base[8]= make_fixnum(length(base[0]));
  2295.     }else{}
  2296.     if(base[17]==Cnil){
  2297.     base[9]= make_fixnum(length(base[1]));
  2298.     }else{}
  2299.     (void)(LI7(base[3],base[4]));
  2300.     (void)(LI9(base[6],base[8]));
  2301.     (void)(LI9(base[7],base[9]));
  2302.     {int V120;
  2303.     int V121;
  2304.     int V122;
  2305.     int V123;
  2306.     V120= fix(base[6]);
  2307.     V121= fix(base[8]);
  2308.     V122= fix(base[7]);
  2309.     V123= fix(base[9]);
  2310.     if((base[2])!=Cnil){
  2311.     goto T1334;}
  2312. T1337:;
  2313.     {int V124;
  2314.     int V125;
  2315.     V124= V120;
  2316.     V125= V122;
  2317. T1343:;
  2318.     if(!((V124)>=(V121))){
  2319.     goto T1344;}
  2320.     base[18]= make_fixnum(V122);
  2321.     vs_top=(vs_base=base+18)+1;
  2322.     return;
  2323. T1344:;
  2324.     if(!((V125)>=(V123))){
  2325.     goto T1348;}
  2326.     base[18]= Cnil;
  2327.     vs_top=(vs_base=base+18)+1;
  2328.     return;
  2329. T1348:;
  2330.     base[19]= elt(base[0],V124);
  2331.     vs_top=(vs_base=base+19)+1;
  2332.     super_funcall_no_event(base[5]);
  2333.     vs_top=sup;
  2334.     base[18]= vs_base[0];
  2335.     base[20]= elt(base[1],V125);
  2336.     vs_top=(vs_base=base+20)+1;
  2337.     super_funcall_no_event(base[5]);
  2338.     vs_top=sup;
  2339.     base[19]= vs_base[0];
  2340.     if((LI5(base[3],base[4],base[18],base[19]))!=Cnil){
  2341.     goto T1351;}
  2342.     goto T1339;
  2343. T1351:;
  2344.     V124= (V124)+1;
  2345.     V125= (V125)+1;
  2346.     goto T1343;}
  2347. T1339:;
  2348.     V122= (V122)+(1);
  2349.     goto T1337;
  2350. T1334:;
  2351. T1365:;
  2352.     {int V126;
  2353.     int V127;
  2354.     V126= (V121)-1;
  2355.     V127= (V123)-1;
  2356. T1371:;
  2357.     if(!((V126)<(V120))){
  2358.     goto T1372;}
  2359.     base[18]= make_fixnum((V127)+1);
  2360.     vs_top=(vs_base=base+18)+1;
  2361.     return;
  2362. T1372:;
  2363.     if(!((V127)<(V122))){
  2364.     goto T1376;}
  2365.     base[18]= Cnil;
  2366.     vs_top=(vs_base=base+18)+1;
  2367.     return;
  2368. T1376:;
  2369.     base[19]= elt(base[0],V126);
  2370.     vs_top=(vs_base=base+19)+1;
  2371.     super_funcall_no_event(base[5]);
  2372.     vs_top=sup;
  2373.     base[18]= vs_base[0];
  2374.     base[20]= elt(base[1],V127);
  2375.     vs_top=(vs_base=base+20)+1;
  2376.     super_funcall_no_event(base[5]);
  2377.     vs_top=sup;
  2378.     base[19]= vs_base[0];
  2379.     if((LI5(base[3],base[4],base[18],base[19]))!=Cnil){
  2380.     goto T1379;}
  2381.     goto T1367;
  2382. T1379:;
  2383.     V126= (V126)-1;
  2384.     V127= (V127)-1;
  2385.     goto T1371;}
  2386. T1367:;
  2387.     V123= (V123)-(1);
  2388.     goto T1365;}
  2389. }
  2390. /*    function definition for SORT    */
  2391.  
  2392. static L51()
  2393. {    register object *base=vs_base;
  2394.     register object *sup=base+VM39;
  2395.     vs_reserve(VM39);
  2396.     if(vs_top-vs_base<2) too_few_arguments();
  2397.     parse_key(vs_base+2,FALSE,FALSE,1,VV[25]);
  2398.     vs_top=sup;
  2399.     if(base[3]==Cnil){
  2400.     base[2]= symbol_function(VV[76]);
  2401.     }else{}
  2402.     if(!(type_of(base[0])==t_cons||base[0]==Cnil)){
  2403.     goto T1394;}
  2404.     base[4]= base[0];
  2405.     base[5]= base[1];
  2406.     base[6]= base[2];
  2407.     vs_top=(vs_base=base+4)+3;
  2408.     L52();
  2409.     return;
  2410. T1394:;
  2411.     base[4]= base[0];
  2412.     base[5]= VV[17];
  2413.     base[6]= make_fixnum(length(base[0]));
  2414.     base[7]= base[1];
  2415.     base[8]= base[2];
  2416.     vs_top=(vs_base=base+4)+5;
  2417.     L55();
  2418.     return;
  2419. }
  2420. /*    function definition for LIST-MERGE-SORT    */
  2421.  
  2422. static L52()
  2423. {    register object *base=vs_base;
  2424.     register object *sup=base+VM40;
  2425.     vs_reserve(VM40);
  2426.     check_arg(3);
  2427.     vs_top=sup;
  2428. TTL:;
  2429.     base[3]= base[0];
  2430.     vs_top=(vs_base=base+3)+1;
  2431.     L53(base);
  2432.     return;
  2433. }
  2434. /*    function definition for QUICK-SORT    */
  2435.  
  2436. static L55()
  2437. {    register object *base=vs_base;
  2438.     register object *sup=base+VM41;
  2439.     vs_reserve(VM41);
  2440.     {int V128;
  2441.     int V129;
  2442.     check_arg(5);
  2443.     V128=fix(base[1]);
  2444.     V129=fix(base[2]);
  2445.     vs_top=sup;
  2446. TTL:;
  2447.     {int V130;
  2448.     int V131;
  2449.     V130= 0;
  2450.     V131= 0;
  2451.     if(!((V129)<=((V128)+1))){
  2452.     goto T1407;}
  2453.     vs_top=(vs_base=base+0)+1;
  2454.     return;
  2455. T1407:;
  2456.     V130= V128;
  2457.     V131= (V129)-1;
  2458.     base[5]= elt(base[0],V128);
  2459. T1417:;
  2460.     if(!((V130)>(V131))){
  2461.     goto T1418;}
  2462.     goto T1414;
  2463. T1418:;
  2464. T1424:;
  2465.     if((V130)>(V131)){
  2466.     goto T1426;}
  2467.     base[7]= elt(base[0],V131);
  2468.     vs_top=(vs_base=base+7)+1;
  2469.     super_funcall_no_event(base[4]);
  2470.     vs_top=sup;
  2471.     base[6]= vs_base[0];
  2472.     base[8]= base[5];
  2473.     vs_top=(vs_base=base+8)+1;
  2474.     super_funcall_no_event(base[4]);
  2475.     vs_top=sup;
  2476.     base[7]= vs_base[0];
  2477.     vs_top=(vs_base=base+6)+2;
  2478.     super_funcall_no_event(base[3]);
  2479.     vs_top=sup;
  2480.     if((vs_base[0])==Cnil){
  2481.     goto T1425;}
  2482. T1426:;
  2483.     goto T1422;
  2484. T1425:;
  2485.     V131= (V131)-(1);
  2486.     goto T1424;
  2487. T1422:;
  2488.     if(!((V131)<(V128))){
  2489.     goto T1439;}
  2490.     base[6]= base[0];
  2491.     base[7]= make_fixnum((V128)+1);
  2492.     base[8]= make_fixnum(V129);
  2493.     base[9]= base[3];
  2494.     base[10]= base[4];
  2495.     vs_top=(vs_base=base+6)+5;
  2496.     L55();
  2497.     vs_top=sup;
  2498.     vs_top=(vs_base=base+0)+1;
  2499.     return;
  2500. T1439:;
  2501. T1450:;
  2502.     if((V130)>(V131)){
  2503.     goto T1452;}
  2504.     base[7]= elt(base[0],V130);
  2505.     vs_top=(vs_base=base+7)+1;
  2506.     super_funcall_no_event(base[4]);
  2507.     vs_top=sup;
  2508.     base[6]= vs_base[0];
  2509.     base[8]= base[5];
  2510.     vs_top=(vs_base=base+8)+1;
  2511.     super_funcall_no_event(base[4]);
  2512.     vs_top=sup;
  2513.     base[7]= vs_base[0];
  2514.     vs_top=(vs_base=base+6)+2;
  2515.     super_funcall_no_event(base[3]);
  2516.     vs_top=sup;
  2517.     if((vs_base[0])!=Cnil){
  2518.     goto T1451;}
  2519. T1452:;
  2520.     goto T1448;
  2521. T1451:;
  2522.     V130= (V130)+(1);
  2523.     goto T1450;
  2524. T1448:;
  2525.     if(!((V130)>(V131))){
  2526.     goto T1465;}
  2527.     goto T1414;
  2528. T1465:;
  2529.     base[6]= make_fixnum(V130);
  2530.     base[7]= elt(base[0],V131);
  2531.     base[8]= make_fixnum(V131);
  2532.     base[9]= elt(base[0],V130);
  2533.     (void)(elt_set(base[0],fixint(base[6]),base[7]));
  2534.     (void)(elt_set(base[0],fixint(base[8]),base[9]));
  2535.     V130= (V130)+(1);
  2536.     V131= (V131)-(1);
  2537.     goto T1417;
  2538. T1414:;
  2539.     base[5]= base[0];
  2540.     base[6]= make_fixnum(V128);
  2541.     base[7]= make_fixnum(V130);
  2542.     base[8]= base[3];
  2543.     base[9]= base[4];
  2544.     vs_top=(vs_base=base+5)+5;
  2545.     L55();
  2546.     vs_top=sup;
  2547.     base[5]= base[0];
  2548.     base[6]= make_fixnum(V130);
  2549.     base[7]= make_fixnum(V129);
  2550.     base[8]= base[3];
  2551.     base[9]= base[4];
  2552.     vs_top=(vs_base=base+5)+5;
  2553.     L55();
  2554.     vs_top=sup;
  2555.     vs_top=(vs_base=base+0)+1;
  2556.     return;}
  2557.     }
  2558. }
  2559. /*    function definition for STABLE-SORT    */
  2560.  
  2561. static L56()
  2562. {    register object *base=vs_base;
  2563.     register object *sup=base+VM42;
  2564.     vs_reserve(VM42);
  2565.     if(vs_top-vs_base<2) too_few_arguments();
  2566.     parse_key(vs_base+2,FALSE,FALSE,1,VV[25]);
  2567.     vs_top=sup;
  2568.     if(base[3]==Cnil){
  2569.     base[2]= symbol_function(VV[76]);
  2570.     }else{}
  2571.     if(!(type_of(base[0])==t_cons||base[0]==Cnil)){
  2572.     goto T1493;}
  2573.     base[4]= base[0];
  2574.     base[5]= base[1];
  2575.     base[6]= base[2];
  2576.     vs_top=(vs_base=base+4)+3;
  2577.     L52();
  2578.     return;
  2579. T1493:;
  2580.     if(type_of(base[0])==t_string){
  2581.     goto T1498;}
  2582.     base[4]= base[0];
  2583.     vs_top=(vs_base=base+4)+1;
  2584.     Lbit_vector_p();
  2585.     vs_top=sup;
  2586.     if((vs_base[0])==Cnil){
  2587.     goto T1499;}
  2588. T1498:;
  2589.     base[4]= base[0];
  2590.     base[5]= base[1];
  2591.     base[6]= VV[25];
  2592.     base[7]= base[2];
  2593.     vs_top=(vs_base=base+4)+4;
  2594.     L51();
  2595.     return;
  2596. T1499:;
  2597.     base[4]=symbol_function(VV[80]);
  2598.     base[7]= base[0];
  2599.     base[8]= VV[2];
  2600.     base[6]= simple_symlispcall_no_event(VV[80],base+7,2);
  2601.     base[7]= base[1];
  2602.     base[8]= base[2];
  2603.     vs_top=(vs_base=base+6)+3;
  2604.     L52();
  2605.     vs_top=sup;
  2606.     base[5]= vs_base[0];
  2607.     base[6]= LI3(base[0]);
  2608.     lispcall_no_event(base+4,2);
  2609.     return;
  2610. }
  2611. /*    function definition for MERGE    */
  2612.  
  2613. static L57()
  2614. {    register object *base=vs_base;
  2615.     register object *sup=base+VM43;
  2616.     vs_reserve(VM43);
  2617.     if(vs_top-vs_base<4) too_few_arguments();
  2618.     parse_key(vs_base+4,FALSE,FALSE,1,VV[25]);
  2619.     vs_top=sup;
  2620.     if(base[5]==Cnil){
  2621.     base[4]= symbol_function(VV[76]);
  2622.     }else{}
  2623.     {int V132;
  2624.     int V133;
  2625.     V132= length(base[1]);
  2626.     V133= length(base[2]);
  2627.     {int V134;
  2628.     int V135;
  2629.     int V136;
  2630.     base[7]= base[0];
  2631.     base[8]= make_fixnum((V132)+(V133));
  2632.     base[6]= simple_symlispcall_no_event(VV[78],base+7,2);
  2633.     V134= 0;
  2634.     V135= 0;
  2635.     V136= 0;
  2636. T1525:;
  2637.     if(!((V135)==(V132))){
  2638.     goto T1526;}
  2639.     if(!((V136)==(V133))){
  2640.     goto T1526;}
  2641.     vs_top=(vs_base=base+6)+1;
  2642.     return;
  2643. T1526:;
  2644.     if(!((V135)<(V132))){
  2645.     goto T1534;}
  2646.     if(!((V136)<(V133))){
  2647.     goto T1534;}
  2648.     base[8]= elt(base[1],V135);
  2649.     vs_top=(vs_base=base+8)+1;
  2650.     super_funcall_no_event(base[4]);
  2651.     vs_top=sup;
  2652.     base[7]= vs_base[0];
  2653.     base[9]= elt(base[2],V136);
  2654.     vs_top=(vs_base=base+9)+1;
  2655.     super_funcall_no_event(base[4]);
  2656.     vs_top=sup;
  2657.     base[8]= vs_base[0];
  2658.     vs_top=(vs_base=base+7)+2;
  2659.     super_funcall_no_event(base[3]);
  2660.     vs_top=sup;
  2661.     if((vs_base[0])==Cnil){
  2662.     goto T1539;}
  2663.     base[7]= elt(base[1],V135);
  2664.     (void)(elt_set(base[6],V134,base[7]));
  2665.     V135= (V135)+(1);
  2666.     goto T1532;
  2667. T1539:;
  2668.     base[8]= elt(base[2],V136);
  2669.     vs_top=(vs_base=base+8)+1;
  2670.     super_funcall_no_event(base[4]);
  2671.     vs_top=sup;
  2672.     base[7]= vs_base[0];
  2673.     base[9]= elt(base[1],V135);
  2674.     vs_top=(vs_base=base+9)+1;
  2675.     super_funcall_no_event(base[4]);
  2676.     vs_top=sup;
  2677.     base[8]= vs_base[0];
  2678.     vs_top=(vs_base=base+7)+2;
  2679.     super_funcall_no_event(base[3]);
  2680.     vs_top=sup;
  2681.     if((vs_base[0])==Cnil){
  2682.     goto T1548;}
  2683.     base[7]= elt(base[2],V136);
  2684.     (void)(elt_set(base[6],V134,base[7]));
  2685.     V136= (V136)+(1);
  2686.     goto T1532;
  2687. T1548:;
  2688.     base[7]= elt(base[1],V135);
  2689.     (void)(elt_set(base[6],V134,base[7]));
  2690.     V135= (V135)+(1);
  2691.     goto T1532;
  2692. T1534:;
  2693.     if(!((V135)<(V132))){
  2694.     goto T1559;}
  2695.     base[7]= elt(base[1],V135);
  2696.     (void)(elt_set(base[6],V134,base[7]));
  2697.     V135= (V135)+(1);
  2698.     goto T1532;
  2699. T1559:;
  2700.     base[7]= elt(base[2],V136);
  2701.     (void)(elt_set(base[6],V134,base[7]));
  2702.     V136= (V136)+(1);
  2703. T1532:;
  2704.     V134= (V134)+1;
  2705.     goto T1525;}}
  2706. }
  2707. /*    local function SORT    */
  2708.  
  2709. static L53(base0)
  2710. register object *base0;
  2711. {    register object *base=vs_base;
  2712.     register object *sup=base+VM44;
  2713.     vs_reserve(VM44);
  2714.     check_arg(1);
  2715.     vs_top=sup;
  2716. TTL:;
  2717.     {int V137;
  2718.     V137= 0;
  2719.     base[1]= Cnil;
  2720.     base[2]= Cnil;
  2721.     base[3]= Cnil;
  2722.     base[4]= Cnil;
  2723.     base[5]= Cnil;
  2724.     base[6]= Cnil;
  2725.     V137= length(base[0]);
  2726.     if(!((V137)<(2))){
  2727.     goto T1577;}
  2728.     vs_top=(vs_base=base+0)+1;
  2729.     return;
  2730. T1577:;
  2731.     if(!((V137)==(2))){
  2732.     goto T1575;}
  2733.     base[7]= car(base[0]);
  2734.     vs_top=(vs_base=base+7)+1;
  2735.     super_funcall_no_event(base0[2]);
  2736.     vs_top=sup;
  2737.     base[5]= vs_base[0];
  2738.     base[7]= cadr(base[0]);
  2739.     vs_top=(vs_base=base+7)+1;
  2740.     super_funcall_no_event(base0[2]);
  2741.     vs_top=sup;
  2742.     base[6]= vs_base[0];
  2743.     base[7]= base[5];
  2744.     base[8]= base[6];
  2745.     vs_top=(vs_base=base+7)+2;
  2746.     super_funcall_no_event(base0[1]);
  2747.     vs_top=sup;
  2748.     if((vs_base[0])==Cnil){
  2749.     goto T1588;}
  2750.     vs_top=(vs_base=base+0)+1;
  2751.     return;
  2752. T1588:;
  2753.     base[7]= base[6];
  2754.     base[8]= base[5];
  2755.     vs_top=(vs_base=base+7)+2;
  2756.     super_funcall_no_event(base0[1]);
  2757.     vs_top=sup;
  2758.     if((vs_base[0])==Cnil){
  2759.     goto T1593;}
  2760.     base[7]= nreverse(base[0]);
  2761.     vs_top=(vs_base=base+7)+1;
  2762.     return;
  2763. T1593:;
  2764.     vs_top=(vs_base=base+0)+1;
  2765.     return;
  2766. T1575:;
  2767.     V137= (V137>=0&&2>0?(V137)/(2):ifloor(V137,2));
  2768.     {int V138;
  2769.     V138= 1;
  2770.     base[7]= base[0];
  2771. T1602:;
  2772.     if(!((V138)>=(V137))){
  2773.     goto T1603;}
  2774.     base[1]= base[0];
  2775.     base[2]= cdr(base[7]);
  2776.     if(type_of(base[7])!=t_cons)FEwrong_type_argument(Scons,base[7]);
  2777.     (base[7])->c.c_cdr = Cnil;
  2778.     goto T1599;
  2779. T1603:;
  2780.     V138= (V138)+1;
  2781.     base[7]= cdr(base[7]);
  2782.     goto T1602;}
  2783. T1599:;
  2784.     base[7]= base[1];
  2785.     vs_top=(vs_base=base+7)+1;
  2786.     L53(base0);
  2787.     vs_top=sup;
  2788.     base[1]= vs_base[0];
  2789.     base[7]= base[2];
  2790.     vs_top=(vs_base=base+7)+1;
  2791.     L53(base0);
  2792.     vs_top=sup;
  2793.     base[2]= vs_base[0];
  2794.     if(!(endp(base[1]))){
  2795.     goto T1623;}
  2796.     vs_top=(vs_base=base+2)+1;
  2797.     return;
  2798. T1623:;
  2799.     if(!(endp(base[2]))){
  2800.     goto T1621;}
  2801.     vs_top=(vs_base=base+1)+1;
  2802.     return;
  2803. T1621:;
  2804.     base[3]= make_cons(Cnil,Cnil);
  2805.     base[4]= base[3];
  2806.     base[7]= car(base[1]);
  2807.     vs_top=(vs_base=base+7)+1;
  2808.     super_funcall_no_event(base0[2]);
  2809.     vs_top=sup;
  2810.     base[5]= vs_base[0];
  2811.     base[7]= car(base[2]);
  2812.     vs_top=(vs_base=base+7)+1;
  2813.     super_funcall_no_event(base0[2]);
  2814.     vs_top=sup;
  2815.     base[6]= vs_base[0];
  2816. T1570:;
  2817.     base[7]= base[5];
  2818.     base[8]= base[6];
  2819.     vs_top=(vs_base=base+7)+2;
  2820.     super_funcall_no_event(base0[1]);
  2821.     vs_top=sup;
  2822.     if((vs_base[0])==Cnil){
  2823.     goto T1637;}
  2824.     goto T1571;
  2825. T1637:;
  2826.     base[7]= base[6];
  2827.     base[8]= base[5];
  2828.     vs_top=(vs_base=base+7)+2;
  2829.     super_funcall_no_event(base0[1]);
  2830.     vs_top=sup;
  2831.     if((vs_base[0])==Cnil){
  2832.     goto T1642;}
  2833.     goto T1572;
  2834. T1642:;
  2835.     goto T1571;
  2836. T1571:;
  2837.     if(type_of(base[4])!=t_cons)FEwrong_type_argument(Scons,base[4]);
  2838.     (base[4])->c.c_cdr = base[1];
  2839.     base[4]= cdr(base[4]);
  2840.     base[1]= cdr(base[1]);
  2841.     if(!(endp(base[1]))){
  2842.     goto T1651;}
  2843.     if(type_of(base[4])!=t_cons)FEwrong_type_argument(Scons,base[4]);
  2844.     (base[4])->c.c_cdr = base[2];
  2845.     base[7]= cdr(base[3]);
  2846.     vs_top=(vs_base=base+7)+1;
  2847.     return;
  2848. T1651:;
  2849.     base[7]= car(base[1]);
  2850.     vs_top=(vs_base=base+7)+1;
  2851.     super_funcall_no_event(base0[2]);
  2852.     vs_top=sup;
  2853.     base[5]= vs_base[0];
  2854.     goto T1570;
  2855. T1572:;
  2856.     if(type_of(base[4])!=t_cons)FEwrong_type_argument(Scons,base[4]);
  2857.     (base[4])->c.c_cdr = base[2];
  2858.     base[4]= cdr(base[4]);
  2859.     base[2]= cdr(base[2]);
  2860.     if(!(endp(base[2]))){
  2861.     goto T1663;}
  2862.     if(type_of(base[4])!=t_cons)FEwrong_type_argument(Scons,base[4]);
  2863.     (base[4])->c.c_cdr = base[1];
  2864.     base[7]= cdr(base[3]);
  2865.     vs_top=(vs_base=base+7)+1;
  2866.     return;
  2867. T1663:;
  2868.     base[7]= car(base[2]);
  2869.     vs_top=(vs_base=base+7)+1;
  2870.     super_funcall_no_event(base0[2]);
  2871.     vs_top=sup;
  2872.     base[6]= vs_base[0];
  2873.     goto T1570;}
  2874. }
  2875. /*    global entry for the function CHECK-SEQ-ARGS    */
  2876.  
  2877. static L11()
  2878. {    register object *base=vs_base;
  2879.     check_arg(4);
  2880.     base[0]=(LI11((base[0]),(base[1]),(base[2]),(base[3])));
  2881.     vs_top=(vs_base=base)+1;
  2882. }
  2883. /*    global entry for the function CHECK-SEQ-START-END    */
  2884.  
  2885. static L9()
  2886. {    register object *base=vs_base;
  2887.     check_arg(2);
  2888.     base[0]=(LI9((base[0]),(base[1])));
  2889.     vs_top=(vs_base=base)+1;
  2890. }
  2891. /*    global entry for the function CHECK-SEQ-TEST    */
  2892.  
  2893. static L7()
  2894. {    register object *base=vs_base;
  2895.     check_arg(2);
  2896.     base[0]=(LI7((base[0]),(base[1])));
  2897.     vs_top=(vs_base=base)+1;
  2898. }
  2899. /*    global entry for the function CALL-TEST    */
  2900.  
  2901. static L5()
  2902. {    register object *base=vs_base;
  2903.     check_arg(4);
  2904.     base[0]=(LI5((base[0]),(base[1]),(base[2]),(base[3])));
  2905.     vs_top=(vs_base=base)+1;
  2906. }
  2907. /*    global entry for the function SEQTYPE    */
  2908.  
  2909. static L3()
  2910. {    register object *base=vs_base;
  2911.     check_arg(1);
  2912.     base[0]=(LI3((base[0])));
  2913.     vs_top=(vs_base=base)+1;
  2914. }
  2915.